clay-server 5.1.1-beta.1 → 5.2.0-beta.10

package/lib/public/modules/pane-activation.js

@@ -0,0 +1,214 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { getCachedSessions } from './sidebar-sessions.js';
+import { takeComposerDraft, restoreComposerDraft } from './input.js';
+import { resetHistoryReplayBatch } from './history-replay-batch.js';
+import { updateContextPanel } from './app-panels.js';
+import { paneTarget, samePaneBinding, samePaneTarget } from './pane-binding.js';
+
+function enabled() {
+  return store.get('paneMode') && !store.get('paneActivationUnsupported') && !store.get('activeProjectMateId') && !/^\/p\/mate-/.test(location.pathname) && !new URLSearchParams(location.search).has('contextual') && window.parent !== window;
+}
+function block(value) {
+  var app = document.getElementById('app');
+  if (app) app.inert = value;
+  document.documentElement.dataset.paneReady = value ? 'false' : 'true';
+}
+function draftKey() { return String(store.get('myUserId')) + ':' + store.get('sessionOriginId'); }
+function clearDeadline() {
+  if (store.get('paneActivationTimer')) clearTimeout(store.get('paneActivationTimer'));
+  store.set({ paneActivationTimer: null });
+}
+function failed(requestId) {
+  var pending = store.get('panePendingBinding');
+  if (!pending || requestId !== pending.requestId) return;
+  clearDeadline();
+  store.set({ paneReady: false, panePendingBinding: null });
+  block(true);
+  var frame = window.frameElement;
+  if (frame) frame.dispatchEvent(new window.parent.CustomEvent('clay-pane-activation-failed'));
+}
+
+// Claim ordinary initial pins before the legacy session-list handler runs.
+// Authentication, list and group metadata can arrive in either order; the
+// subscription retries when those authoritative prerequisites become ready.
+export function primePaneSession() {
+  if (!enabled() || !window.frameElement || !window.frameElement.clayPane) return false;
+  var id = store.get('paneSessionId');
+  var session = (getCachedSessions() || []).find(function (item) { return item.id === id; });
+  if (!session || session.isMate || (session.runtimeMode || session.mode || 'gui') !== 'gui' || session.tuiSuspended) return false;
+  activatePaneSession(id);
+  return true;
+}
+
+export function activatePaneSession(id, force, expectedTarget) {
+  var state = store.snap(), ws = getWs();
+  if (state.authIdentityLoaded === false) return false;
+  if (state.isMultiUserMode && !state.myUserId) return false;
+  if (!enabled() || !state.connected || !ws || ws.readyState !== 1 || state.splitGroupsProjectSlug !== state.currentSlug) return false;
+  var target = paneTarget(state, getCachedSessions(), id);
+  if (!target) return false;
+  if (expectedTarget && !samePaneTarget(target, expectedTarget)) return false;
+  var sourceFrame = window.frameElement;
+  if (!expectedTarget && sourceFrame && Number(sourceFrame.dataset && sourceFrame.dataset.sessionId) === id && sourceFrame.dataset.sessionOriginId && sourceFrame.dataset.sessionOriginId !== target.sessionOriginId) return false;
+  var old = state.paneCommittedBinding, pending = state.panePendingBinding;
+  if (!force && !state.paneSuspended && samePaneTarget(pending || old, target)) return true;
+  if (!pending && state.sessionOriginId) {
+    var draft;
+    try { draft = takeComposerDraft(); } catch (error) { return false; }
+    var drafts = Object.assign({}, state.paneRichDrafts || {});
+    drafts[draftKey()] = draft;
+    store.set({ paneRichDrafts: drafts });
+  }
+  clearDeadline();
+  resetHistoryReplayBatch();
+  var generation = (store.get('paneActivationGeneration') || 0) + 1;
+  target = Object.assign({}, target, { generation: generation, requestId: 'pane-' + generation + '-' + Math.random().toString(36).slice(2, 12) });
+  var path = new URL(store.get('wsPath'), location.origin);
+  path.searchParams.set('session', String(id));
+  store.set({ paneActivationGeneration: generation, panePendingBinding: target, paneReady: false, paneSuspended: false,
+    paneSessionId: id, panePinPending: false, wsPath: path.pathname + path.search });
+  block(true);
+  store.set({ paneActivationTimer: setTimeout(function () { failed(target.requestId); }, 12000) });
+  ws.send(JSON.stringify({ type: 'switch_session', id: id, paneActivation: target }));
+  return true;
+}
+
+// Runs before replay batching, so an obsolete history_meta cannot open a batch
+// that later consumes destination messages.
+export function filterPaneActivation(message) {
+  if (!enabled()) return false;
+  var pending = store.get('panePendingBinding'), committed = store.get('paneCommittedBinding');
+  if (message.type === 'pane_activation_rejected') { failed(message.requestId); return true; }
+  if (!pending && !committed) return !!message.paneActivation;
+  if (['session_list', 'split_groups', 'session_presence', 'pong', 'account_auth_required', 'project_removed', 'project_access_revoked'].indexOf(message.type) >= 0 && !message.paneActivation) return false;
+  var expected = pending || committed;
+  if (!samePaneBinding(expected, message.paneActivation)) return true;
+  if (message.type === 'pane_activation_started') return true;
+  if (message.type === 'pane_activation_snapshot_done') {
+    if (!pending) return true;
+    var draft = (store.get('paneRichDrafts') || {})[String(store.get('myUserId')) + ':' + expected.sessionOriginId];
+    restoreComposerDraft(draft || { text: '', start: 0, end: 0 });
+    function paint() {
+      if (store.get('panePendingBinding') !== expected || !store.get('connected') || store.get('paneSuspended')) return;
+      var current = paneTarget(store.snap(), getCachedSessions(), expected.sessionId);
+      var messages = document.getElementById('messages');
+      if (!samePaneTarget(current, expected) ||
+        store.get('activeSessionId') !== expected.sessionId || store.get('sessionOriginId') !== expected.sessionOriginId || store.get('replayingHistory') ||
+        !messages || messages.dataset.controlSessionId !== String(expected.sessionId) || messages.dataset.controlSessionOrigin !== expected.sessionOriginId) { failed(expected.requestId); return; }
+      clearDeadline();
+      store.set({ paneCommittedBinding: expected, panePendingBinding: null, paneReady: true });
+      block(false);
+      var frame = window.frameElement;
+      if (frame) frame.dispatchEvent(new window.parent.CustomEvent('clay-pane-ready'));
+      updateContextPanel();
+    }
+    requestAnimationFrame(function () { requestAnimationFrame(paint); });
+    return true;
+  }
+  return false;
+}
+
+export function paneOutgoing(data) {
+  var message;
+  try { message = JSON.parse(data); } catch (error) { return null; }
+  if (['ping', 'pong', 'clay_ui_ready'].indexOf(message.type) >= 0) return data;
+  if (store.get('deferredSessionSwitch') && store.get('deferredSessionSwitch').draining) return null;
+  if (message.type === 'switch_session') {
+    var entry = store.get('pendingSessionEntryNavigation');
+    if (entry && entry.projectSlug === store.get('currentSlug') && String(entry.sessionId) !== String(message.id)) store.set({ pendingSessionEntryNavigation: null });
+    if (enabled() && (store.get('panePendingBinding') || store.get('paneCommittedBinding')) && !message.paneActivation) return null;
+    return data;
+  }
+  if (store.get('deferredSessionSwitch')) {
+    var source = store.get('deferredSessionSwitch');
+    if (source.draining) return null;
+    if (message.type === 'stop') return JSON.stringify(Object.assign({}, message, { sessionId: source.sessionId, sessionOriginId: source.origin }));
+    return null;
+  }
+  if (!enabled()) return data;
+  var binding = store.get('paneCommittedBinding');
+  if (store.get('panePendingBinding') || store.get('paneSuspended') || binding && !store.get('paneReady')) return null;
+  if (!binding) return ['stop', 'user_message', 'permission_response', 'ask_user_response', 'elicitation_response', 'user_dialog_response', 'input_sync'].indexOf(message.type) >= 0 ? null : data;
+  if (message.paneBinding && !samePaneBinding(binding, message.paneBinding)) return null;
+  var gesture = (store.get('paneActionEvents') || []).find(function (entry) { return entry.event.isTrusted && entry.event.eventPhase && samePaneBinding(entry.binding, binding); });
+  var action = store.get('paneCallbackBinding') || gesture && gesture.binding;
+  var read = /^(get_|list_)|(_get|_list|_options)$/.test(message.type) || message.type === 'load_more_history';
+  if (!message.paneBinding && !read && !samePaneBinding(action, binding)) return null;
+  return JSON.stringify(Object.assign({}, message, { paneBinding: message.paneBinding || action || binding }));
+}
+
+export function refreshPaneActivation() {
+  if (!enabled()) return;
+  var binding = store.get('panePendingBinding') || store.get('paneCommittedBinding');
+  if (!binding) return;
+  var current = paneTarget(store.snap(), getCachedSessions(), binding.sessionId);
+  if (samePaneTarget(current, binding)) return;
+  if (store.get('panePendingBinding')) failed(binding.requestId);
+  else { store.set({ paneReady: false }); block(true); }
+}
+
+export function initPaneActivation() {
+  if (!enabled() || !window.frameElement) return;
+  var frame = window.frameElement;
+  var latestId = Number(frame.dataset && (frame.dataset.requestedSessionId || frame.dataset.sessionId));
+  if (Number.isSafeInteger(latestId) && latestId > 0 && frame.dataset.projectSlug === store.get('currentSlug')) {
+    var latestPath = new URL(store.get('wsPath'), location.origin);
+    latestPath.searchParams.set('session', String(latestId));
+    store.set({ paneSessionId: latestId, panePinPending: true, wsPath: latestPath.pathname + latestPath.search });
+  }
+  block(true);
+  frame.clayPane = {
+    source: window, document: document,
+    identity: function () {
+      var binding = store.get('paneCommittedBinding');
+      return binding && { ownerId: binding.viewerId, projectSlug: binding.projectSlug, sessionId: binding.sessionId,
+        binding: binding, ready: store.get('connected') && store.get('paneReady') && !store.get('paneSuspended') };
+    },
+    activate: activatePaneSession,
+    checkDraft: function () { if (!store.get('panePendingBinding')) { var draft = takeComposerDraft(); restoreComposerDraft(draft); } },
+    suspend: function () { store.set({ paneSuspended: true, paneReady: false }); block(true); },
+  };
+  // A pointer that began on the previous conversation cannot become a Stop or
+  // approval click on the replacement conversation after hydration.
+  document.addEventListener('pointerdown', function () { store.set({ panePointerBinding: store.get('paneCommittedBinding') }); }, true);
+  document.addEventListener('click', function (event) {
+    if (store.get('paneSuspended') || !store.get('paneReady') && store.get('panePendingBinding') || event.detail && store.get('panePointerBinding') !== store.get('paneCommittedBinding')) {
+      event.preventDefault(); event.stopImmediatePropagation();
+    }
+  }, true);
+  ['click', 'input', 'change', 'keydown', 'keyup', 'submit', 'blur'].forEach(function (name) {
+    document.addEventListener(name, function (event) {
+      var keys = store.get('paneHeldKeys') || {};
+      var binding = store.get('paneCommittedBinding');
+      var previousKey = keys[event.code || event.key];
+      var staleKey = (name === 'keyup' || name === 'keydown' && event.repeat) && previousKey && !samePaneBinding(previousKey, binding);
+      if (name === 'keydown' && !event.repeat) keys[event.code || event.key] = binding;
+      if (name === 'keyup') delete keys[event.code || event.key];
+      if (staleKey || store.get('panePendingBinding') || store.get('paneSuspended') || !store.get('paneReady')) {
+        event.preventDefault(); event.stopImmediatePropagation(); return;
+      }
+      var events = (store.get('paneActionEvents') || []).filter(function (entry) { return entry.event.eventPhase; });
+      events.push({ event: event, binding: binding });
+      store.set({ paneHeldKeys: keys, paneActionEvents: events });
+    }, true);
+  });
+  store.subscribe(function (state, previous) {
+    if (state.activeSessionMode === 'tui' && previous.activeSessionMode !== 'tui') {
+      delete frame.clayPane; store.set({ paneActivationUnsupported: true }); block(false); return;
+    }
+    if (!state.connected && previous.connected) {
+      clearDeadline();
+      store.set({ paneReady: false, panePendingBinding: null, paneCommittedBinding: null }); block(true);
+    }
+    if (state.connected && (state.splitGroups !== previous.splitGroups || state.splitGroupsProjectSlug !== previous.splitGroupsProjectSlug || state.paneBindingSessions !== previous.paneBindingSessions || state.authIdentityLoaded !== previous.authIdentityLoaded || state.myUserId !== previous.myUserId || state.activeSessionId !== previous.activeSessionId || state.connected !== previous.connected)) {
+      queueMicrotask(function () {
+        refreshPaneActivation();
+        if (!store.get('panePendingBinding') && !store.get('paneSuspended')) {
+          if (store.get('panePinPending')) primePaneSession();
+          else if (store.get('activeSessionId') === store.get('paneSessionId')) activatePaneSession(store.get('paneSessionId'));
+        }
+      });
+    }
+  });
+}

package/lib/public/modules/pane-binding.js

@@ -0,0 +1,82 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+
+export function captureSessionAction() {
+  var state = store.snap();
+  return { projectSlug: state.currentSlug, ownerId: state.myUserId, sessionId: state.activeSessionId,
+    origin: state.sessionOriginId, socket: getWs(), binding: state.paneCommittedBinding || null,
+    epoch: state.sessionActionEpoch || 0 };
+}
+
+export function sessionActionCurrent(action, draftCompletion) {
+  var state = store.snap();
+  return !!action && action.socket === getWs() && state.connected &&
+    action.projectSlug === state.currentSlug && action.ownerId === state.myUserId &&
+    action.sessionId === state.activeSessionId && action.origin === state.sessionOriginId &&
+    action.epoch === (state.sessionActionEpoch || 0) &&
+    (draftCompletion || !state.deferredSessionSwitch) && !state.panePendingBinding && !state.paneSuspended &&
+    (action.binding ? state.paneReady && samePaneBinding(action.binding, state.paneCommittedBinding) : !state.paneCommittedBinding);
+}
+
+// Capture at callback creation, never when an old callback eventually sends.
+export function sessionCallback(callback, draftCompletion) {
+  var action = captureSessionAction();
+  return function () {
+    if (!sessionActionCurrent(action, draftCompletion)) return;
+    var previous = store.get('paneCallbackBinding');
+    store.set({ paneCallbackBinding: action.binding });
+    try { return callback.apply(this, arguments); }
+    finally { store.set({ paneCallbackBinding: previous }); }
+  };
+}
+
+export function samePaneBinding(a, b) {
+  return !!a && !!b && ['requestId', 'generation', 'projectSlug', 'viewerId', 'ownerId', 'sessionId', 'sessionOriginId', 'role', 'workerGeneration', 'groupStamp', 'parentSessionOriginId'].every(function (key) { return a[key] === b[key]; });
+}
+
+export function samePaneTarget(a, b) {
+  return !!a && !!b && ['projectSlug', 'viewerId', 'ownerId', 'sessionId', 'sessionOriginId', 'role', 'workerGeneration', 'groupStamp', 'parentSessionOriginId'].every(function (key) { return a[key] === b[key]; });
+}
+
+export function paneTarget(state, sessions, id) {
+  var session = (sessions || []).find(function (item) { return item.id === id; });
+  if (!session || session.isMate || !session.sessionOriginId || (session.runtimeMode || session.mode || 'gui') !== 'gui' || session.tuiSuspended) return null;
+  var group = (state.splitGroups || []).find(function (item) { return item.members.indexOf(id) >= 0; });
+  var parent = session.sessionRole === 'worker' && sessions.find(function (item) { return item.id === session.parentSessionId; });
+  if (session.sessionRole === 'worker' && (!parent || !session.parentAvailable || !Number.isSafeInteger(session.workerGeneration) || !parent.sessionOriginId || parent.ownerId !== session.ownerId || !group || !group.pair || group.pair.driverId !== parent.id)) return null;
+  return {
+    projectSlug: state.currentSlug, viewerId: state.myUserId || null, ownerId: session.ownerId || null,
+    sessionId: session.id, sessionOriginId: session.sessionOriginId,
+    role: session.sessionRole === 'worker' ? 'worker' : 'driver', workerGeneration: session.workerGeneration || null,
+    parentSessionOriginId: parent ? parent.sessionOriginId : null,
+    groupStamp: group ? JSON.stringify({ id: group.id, members: group.members, pair: group.pair || null }) : null,
+  };
+}
+
+// Ordinary reusable panes have a live document binding; legacy/canonical frames
+// retain their existing URL and receipt checks in their own bridge paths.
+export function livePaneBinding(frame, message) {
+  if (!frame || !frame.clayPane) return false;
+  var api = frame.clayPane, live = api.identity();
+  var state = store.snap(), split = state.splitPanes;
+  var target = live && paneTarget(state, state.paneBindingSessions || [], live.sessionId);
+  return api.source === frame.contentWindow && api.document === frame.contentDocument && live && live.ready &&
+    samePaneTarget(target, live.binding) &&
+    live.ownerId === (state.myUserId || null) && live.projectSlug === state.currentSlug &&
+    split && split.panes.some(function (pane) { return pane.slug === live.projectSlug && pane.sessionId === live.sessionId; }) &&
+    (!message || samePaneBinding(live.binding, message.paneBinding));
+}
+
+export function paneMessageBinding() {
+  return store.get('paneReady') && !store.get('paneSuspended') ? store.get('paneCommittedBinding') : null;
+}
+
+export function currentPaneReview(container) {
+  if (!container || !container.paneBinding) return true;
+  return container.isConnected !== false && store.get('paneReady') && !store.get('paneSuspended') && samePaneBinding(container.paneBinding, store.get('paneCommittedBinding'));
+}
+
+export function paneCallbackCurrent(binding) {
+  var current = store.get('panePendingBinding') || store.get('paneCommittedBinding');
+  return current ? samePaneBinding(current, binding) : !binding;
+}

package/lib/public/modules/pane-bridge.js

@@ -1,9 +1,11 @@
+import { forwardStudioPresentation } from './clay-studio-render.js';
 // Pane-side postMessage bridge for the split-view shell. A chrome-less pane
 // iframe reports its context usage up to the parent (which renders a chip in
 // the pane header) and honors panel-toggle requests coming back down.
 // Same-origin messages only, both directions.
 
 import { store } from './store.js';
+import { paneMessageBinding, samePaneBinding } from './pane-binding.js';
 import { getEffectiveContextView } from './context-view-preference.js';
 import { forceExternalLinkToNewTab } from './pane-links.js';
 
@@ -11,6 +13,7 @@ export function reportPaneContext(data) {
   if (!store.get('paneMode') || window.parent === window) return;
   window.parent.postMessage({
     type: "clay-pane-context",
+    paneBinding: paneMessageBinding(),
     sessionId: store.get('activeSessionId'),
     pct: data.pct,
     used: data.used,
@@ -26,19 +29,18 @@ export function reportPaneContext(data) {
 // Hand the event to the parent shell, which owns the single flow.
 export function forwardPaneAuthRequired(message) {
   if (!store.get('paneMode') || window.parent === window) return false;
-  window.parent.postMessage({ type: "clay-pane-auth-required", message: message }, window.location.origin);
+  window.parent.postMessage({ type: "clay-pane-auth-required", paneBinding: paneMessageBinding(), message: message }, window.location.origin);
   return true;
 }
 
 export function forwardPaneMarkdownPresentation(message) {
   if (!store.get('paneMode') || window.parent === window) return false;
-  window.parent.postMessage({ type: "clay-pane-present-markdown", message: message }, window.location.origin);
-  return true;
+  return forwardStudioPresentation(message, "clay-pane-present-markdown");
 }
 
 export function forwardPaneIssueReference(ref, projectSlug) {
   if (!store.get('paneMode') || window.parent === window) return false;
-  window.parent.postMessage({ type: "clay-pane-open-issue", ref: ref, projectSlug: projectSlug || store.get('currentSlug') }, window.location.origin);
+  window.parent.postMessage({ type: "clay-pane-open-issue", paneBinding: paneMessageBinding(), ref: ref, projectSlug: projectSlug || store.get('currentSlug') }, window.location.origin);
   return true;
 }
 
@@ -70,6 +72,7 @@ export function initPaneBridge() {
     if (event.origin !== window.location.origin) return;
     var msg = event.data;
     if (!msg || msg.type !== "clay-pane-toggle-context") return;
+    if (event.source !== window.parent || store.get('paneCommittedBinding') && !samePaneBinding(paneMessageBinding(), msg.paneBinding)) return;
     togglePaneContextPanel();
   });
 }

package/lib/public/modules/pane-browser-bridge.js

@@ -0,0 +1,22 @@
+import { store } from './store.js';
+import { livePaneBinding, paneMessageBinding } from './pane-binding.js';
+import { showToast } from './utils.js';
+
+export function forwardPaneBrowserLink(url) {
+  if (!store.get('paneMode') || window.parent === window) return false;
+  window.parent.postMessage({ type: 'clay-pane-open-browser', paneBinding: paneMessageBinding(), url: url, projectSlug: store.get('currentSlug'), sessionId: String(store.get('activeSessionId')) }, window.location.origin);
+  return true;
+}
+export function handlePaneBrowserMessage(event, host) {
+  if (!event || event.origin !== window.location.origin || !host || !event.data || event.data.type !== 'clay-pane-open-browser') return false;
+  var msg = event.data, s = store.snap();
+  var frame = Array.from(host.querySelectorAll('.split-pane-frame')).find(function (item) { return item.contentWindow === event.source; });
+  var pane = frame && s.splitPanes && s.splitPanes.panes && s.splitPanes.panes.find(function (item) { return String(item.slug) === frame.dataset.projectSlug && String(item.sessionId) === frame.dataset.sessionId; });
+  if (!pane || msg.projectSlug !== s.currentSlug || msg.projectSlug !== frame.dataset.projectSlug || String(msg.sessionId) !== frame.dataset.sessionId) return true;
+  var expected = new URL('/p/' + encodeURIComponent(pane.slug) + '/?pane=1&session=' + encodeURIComponent(pane.sessionId), window.location.href).href;
+  if (frame.clayPane ? !livePaneBinding(frame, msg) : frame.src !== expected) return true;
+  // The authenticated host owns the browser; a live same-project pane supplies only a URL.
+  var binding = frame.clayPane && frame.clayPane.identity().binding;
+  import('./shared-browser.js').then(function (module) { if (binding && (!livePaneBinding(frame, msg) || frame.clayPane.identity().binding !== binding)) return; module.openSharedBrowserAt(msg.url); }).catch(function (error) { showToast(error.message || 'Could not open the browser.', 'warn'); });
+  return true;
+}

package/lib/public/modules/pane-file-bridge.js

@@ -1,4 +1,5 @@
 import { store } from './store.js';
+import { livePaneBinding, paneMessageBinding } from './pane-binding.js';
 
 function paneFrame(host, source) {
   if (!host || !source) return null;
@@ -19,6 +20,7 @@ function matchingPane(frame, split) {
 }
 
 function hasLivePaneSource(frame, pane) {
+  if (frame && frame.clayPane) return livePaneBinding(frame);
   if (!frame || !pane || typeof frame.src !== "string") return false;
   var expected = "/p/" + encodeURIComponent(pane.slug) + "/?pane=1&session=" + encodeURIComponent(pane.sessionId);
   try { return new URL(expected, window.location.href).href === frame.src; } catch (e) { return false; }
@@ -41,6 +43,7 @@ export function forwardPaneFileReference(path, opts) {
   if (!store.get('paneMode') || window.parent === window || typeof path !== "string" || !path) return false;
   window.parent.postMessage({
     type: "clay-pane-open-file",
+    paneBinding: paneMessageBinding(),
     path: path,
     line: opts && opts.line != null ? opts.line : null,
     column: opts && opts.column != null ? opts.column : null,
@@ -57,6 +60,7 @@ export function handlePaneFileMessage(event, host, openFile, openFiles) {
   var frame = paneFrame(host, event.source);
   var state = store.snap();
   var pane = matchingPane(frame, state.splitPanes);
+  if (frame && frame.clayPane && !livePaneBinding(frame, msg)) return true;
   if (!pane || !hasLivePaneSource(frame, pane) || String(pane.slug) !== String(state.currentSlug) || msg.projectSlug !== frame.dataset.projectSlug || String(msg.sessionId) !== String(frame.dataset.sessionId) || !validLocation(msg.line) || !validLocation(msg.column)) return true;
   if (typeof msg.path !== "string" || !msg.path) return true;
   if (!state.connected || typeof openFile !== "function") return true;

package/lib/public/modules/pane-issue-bridge.js

@@ -1,4 +1,5 @@
 import { store } from './store.js';
+import { livePaneBinding } from './pane-binding.js';
 import { openIssues } from './issues.js';
 
 function isIssueReference(ref) {
@@ -8,7 +9,7 @@ function isIssueReference(ref) {
 function isPaneSource(host, source) {
   var frames = host.querySelectorAll(".split-pane-frame");
   for (var i = 0; i < frames.length; i++) {
-    if (frames[i].contentWindow === source) return true;
+    if (frames[i].contentWindow === source) return !frames[i].clayPane || livePaneBinding(frames[i]);
   }
   return false;
 }
@@ -18,6 +19,8 @@ export function handlePaneIssueMessage(event, host) {
   var msg = event.data;
   if (!msg || msg.type !== "clay-pane-open-issue") return false;
   if (!isIssueReference(msg.ref) || !isPaneSource(host, event.source)) return true;
+  var frame = Array.from(host.querySelectorAll('.split-pane-frame')).find(function (item) { return item.contentWindow === event.source; });
+  if (frame && frame.clayPane && !livePaneBinding(frame, msg)) return true;
 
   var issueTarget = store.get('issuesCache') && store.get('issuesCache')[msg.ref];
   var projectSlug = (issueTarget && issueTarget.projectSlug) || msg.projectSlug || store.get('currentSlug');

package/lib/public/modules/passkey-browser.js

@@ -0,0 +1,69 @@
+function decode(value) {
+  var base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+  return Uint8Array.from(atob(base64), function (character) { return character.charCodeAt(0); });
+}
+function encode(value) {
+  var bytes = new Uint8Array(value); var binary = '';
+  bytes.forEach(function (byte) { binary += String.fromCharCode(byte); });
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function serialize(credential) {
+  if (!credential) throw new Error('No passkey was selected.');
+  var response = { clientDataJSON: encode(credential.response.clientDataJSON) };
+  ['attestationObject', 'authenticatorData', 'signature', 'userHandle'].forEach(function (key) {
+    if (credential.response[key]) response[key] = encode(credential.response[key]);
+  });
+  if (credential.response.getTransports) response.transports = credential.response.getTransports();
+  return { id: credential.id, rawId: encode(credential.rawId), type: credential.type, response: response,
+    clientExtensionResults: credential.getClientExtensionResults(), authenticatorAttachment: credential.authenticatorAttachment };
+}
+function prepare(options) {
+  var publicKey = Object.assign({}, options, { challenge: decode(options.challenge) });
+  ['allowCredentials', 'excludeCredentials'].forEach(function (field) {
+    if (options[field]) publicKey[field] = options[field].map(function (key) { return Object.assign({}, key, { id: decode(key.id) }); });
+  });
+  if (options.user) publicKey.user = Object.assign({}, options.user, { id: decode(options.user.id) });
+  return publicKey;
+}
+export function supported() { return !!(window.isSecureContext && window.PublicKeyCredential && navigator.credentials); }
+export function passkeyError(error) {
+  if (error.name === 'NotAllowedError' || error.name === 'AbortError') return 'Passkey request cancelled or timed out. You can try again or use your password.';
+  if (error.name === 'InvalidStateError') return 'This passkey is already registered. Choose a different device or passkey.';
+  return error.message || 'Could not use this passkey.';
+}
+export async function createPasskey(options) {
+  if (!supported()) throw new Error('Passkeys need a supported browser and a secure connection.');
+  return serialize(await navigator.credentials.create({ publicKey: prepare(options) }));
+}
+export async function getPasskey(options) {
+  if (!supported()) throw new Error('Passkeys need a supported browser and a secure connection.');
+  return serialize(await navigator.credentials.get({ publicKey: prepare(options) }));
+}
+export async function request(url, data) {
+  var response = await fetch(url, data === undefined ? { credentials: 'same-origin' } : {
+    method: 'POST', credentials: 'same-origin', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data),
+  });
+  var result = await response.json();
+  if (!response.ok) throw new Error(result.error || 'Could not complete this request.');
+  return result;
+}
+export async function initPasskeyLogin() {
+  var button = document.getElementById('passkey-login');
+  if (!button || !supported()) return;
+  try {
+    var status = await request('/auth/passkeys/status');
+    if (status.origin !== location.origin || document.getElementById('mode-row').hidden) return;
+    button.hidden = false;
+    button.onclick = async function () {
+      button.disabled = true;
+      var error = document.getElementById('error'); error.textContent = '';
+      try {
+        var options = await request('/auth/passkeys/login/options', {});
+        var response = await getPasskey(options.options);
+        await request('/auth/passkeys/login/verify', { response: response });
+        location.href = '/';
+      } catch (failure) { error.textContent = passkeyError(failure); }
+      finally { button.disabled = false; }
+    };
+  } catch (failure) { /* Password sign-in remains available when passkeys cannot load. */ }
+}

package/lib/public/modules/passkey-server-settings.js

@@ -0,0 +1,57 @@
+import { store } from './store.js';
+import { setSettingsDraft, clearSettingsDraft } from './server-settings-state.js';
+
+function render(state) {
+  var section = document.getElementById('passkey-policy');
+  if (!section) return;
+  section.hidden = !state.available;
+  var input = section.querySelector('[name=origin]');
+  if (state.draft === undefined) input.value = state.origin || '';
+  input.disabled = !!state.pending || !!state.locked;
+  section.querySelector('[name=currentPassword]').disabled = !!state.pending;
+  section.querySelector('button').disabled = !!state.pending || !!state.locked;
+  section.querySelector('[data-passkey-editor]').hidden = !!state.locked;
+  section.querySelector('[role=status]').textContent = state.error || (state.pending ? 'Saving…' : state.origin ?
+    'Passkeys are available at ' + state.origin + (state.locked ? '. Remove registered passkeys before changing this address.' : '.') : 'Not configured. Password sign-in remains available.');
+}
+export async function loadPasskeyServerSettings() {
+  if (!document.getElementById('passkey-policy') || (store.get('passkeyPolicy') || {}).draft !== undefined) return;
+  try {
+    var response = await fetch('/api/passkey-policy'); var data = await response.json();
+    if (!response.ok) throw new Error(data.error || 'Could not load passkey settings.');
+    store.set({ passkeyPolicy: data }); render(data);
+  } catch (error) {
+    var state = Object.assign({}, store.get('passkeyPolicy'), { error: error.message });
+    store.set({ passkeyPolicy: state }); render(state);
+  }
+}
+export function initPasskeyServerSettings() {
+  var anchor = document.getElementById('account-auth-policy');
+  if (!anchor || document.getElementById('passkey-policy')) return;
+  var section = document.createElement('section'); section.id = 'passkey-policy'; section.className = 'settings-card'; section.hidden = true;
+  section.innerHTML = '<h3>Passkey sign-in address</h3><p class="settings-hint">Configure the shared server address for passkey sign-in. Users register and manage their own passkeys in Personal settings → Account. Passwords remain available.</p>' +
+    '<form><label class="settings-label" for="passkey-origin">Sign-in address</label><input class="us-text-input" id="passkey-origin" name="origin" type="url" placeholder="https://clay.example.com" required>' +
+    '<p class="settings-hint">Use the permanent HTTPS address for this server. Local development can use http://localhost with its port.</p>' +
+    '<div data-passkey-editor><label class="settings-label" for="passkey-admin-password">Administrator password</label><input class="us-text-input" id="passkey-admin-password" name="currentPassword" type="password" autocomplete="current-password" required>' +
+    '<div class="settings-form-actions"><button class="settings-btn-sm" type="submit">Save passkey address</button></div></div></form><p class="settings-hint" role="status"></p>';
+  anchor.after(section);
+  var input = section.querySelector('[name=origin]');
+  input.oninput = function () {
+    var state = Object.assign({}, store.get('passkeyPolicy'), { draft: input.value, error: '' });
+    if (input.value === (state.origin || '')) { delete state.draft; clearSettingsDraft('passkeys'); }
+    else setSettingsDraft('passkeys', true);
+    store.set({ passkeyPolicy: state }); render(state);
+  };
+  section.querySelector('form').onsubmit = async function (event) {
+    event.preventDefault();
+    var state = Object.assign({}, store.get('passkeyPolicy'), { pending: true, error: '' });
+    store.set({ passkeyPolicy: state }); render(state);
+    var password = section.querySelector('[name=currentPassword]');
+    try {
+      var response = await fetch('/api/passkey-policy', { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ origin: input.value, currentPassword: password.value }) });
+      var data = await response.json(); if (!response.ok) throw new Error(data.error || 'Could not save passkey settings.');
+      state = data; clearSettingsDraft('passkeys');
+    } catch (error) { state.pending = false; state.error = error.message; }
+    finally { password.value = ''; store.set({ passkeyPolicy: state }); render(state); }
+  };
+}

package/lib/public/modules/pending-message-queue.js

@@ -330,6 +330,7 @@ function renderItem(item, index) {
   var disabled = controlsDisabled ? ' disabled aria-disabled="true"' : '';
   var text = (item.message && item.message.text || "").trim() || "Attachment-only message";
   var html = '<div class="pending-message-chip' + (item.state === "claimed" ? ' is-claimed' : '') + (scheduled ? ' is-scheduled' : '') + (futureScheduled ? ' is-future' : '') + '" data-pending-id="' + escapeHtml(item.id) + '">';
+  if (item.schedule && item.schedule.logicalScheduleId) html = html.replace('data-pending-id=', 'data-control-schedule-id="' + escapeHtml(item.schedule.logicalScheduleId) + '" data-control-revision="' + escapeHtml(item.schedule.logicalRevision || '') + '" data-control-runtime="' + escapeHtml(store.get('controlRuntimeId') || '') + '" data-pending-id=');
   html += '<span class="pending-message-number" aria-hidden="true">' + (index + 1) + '</span>';
   if (own && item.state === "pending") html += '<button class="pending-message-drag" type="button" data-action="drag" aria-label="Reorder queued message ' + (index + 1) + '" title="Drag, or use arrow keys to reorder"' + disabled + '>' + '<i data-lucide="grip-vertical"></i></button>';
   else html += '<span class="pending-message-drag is-static"><i data-lucide="' + (item.state === "claimed" ? "loader-circle" : "lock-keyhole") + '"></i></span>';

package/lib/public/modules/permission-control.js

@@ -66,7 +66,7 @@ export function permissionStatusText(state, pending, autoSupported, autoVisible)
   if (state.permissionMode === "plan") return "Plan workflow";
   if (state.permissionMode === "acceptEdits") return "Auto-accept edits workflow";
   if (state.permissionMode === "dontAsk") return "Don't ask workflow";
-  if (autoVisible && !autoSupported) return "Auto unavailable for this Claude session";
+  if (autoVisible && !autoSupported) return "Auto unavailable for this session";
   if (state.permissionMode === "auto" && !state.effectivePermissionMode) return "Auto selected · waiting for runtime";
   if (state.permissionMode === "auto" && state.effectivePermissionMode !== "auto") {
     return "Auto unavailable at runtime · using " + modeLabel(state.effectivePermissionMode);
@@ -91,7 +91,8 @@ export function renderPermissionControl(control, state) {
   var projectSlug = state.projectSlug || "";
   var sessionId = state.sessionId || null;
   var pending = permissionPendingFor(projectSlug, sessionId);
-  var autoVisible = state.vendor === "claude";
+  var description = ((store.get("vendorInfo") || {})[state.vendor] || {}).configuration || {};
+  var autoVisible = description.auto === true || !!(state.permissionCapabilities && state.permissionCapabilities.auto === true);
   var autoSupported = !!(state.permissionCapabilities && state.permissionCapabilities.auto === true);
   var globallyForced = state.globalPermissionModeForced === true;
   var connected = state.connected !== false && !!getWs() && getWs().readyState === 1;
@@ -114,7 +115,7 @@ export function renderPermissionControl(control, state) {
     buttons[i].classList.toggle("pending", requested);
     buttons[i].setAttribute("aria-pressed", selected ? "true" : "false");
     buttons[i].setAttribute("aria-busy", requested ? "true" : "false");
-    buttons[i].title = unsupported ? "Auto permissions are unavailable for this Claude session." : buttonTitles[mode];
+    buttons[i].title = unsupported ? "Auto permissions are unavailable for this session." : buttonTitles[mode];
   }
   var status = control.querySelector(".session-permission-status");
   if (status) {
@@ -138,7 +139,7 @@ export function bindPermissionControl(control, getState) {
     var autoSupported = !!(state.permissionCapabilities && state.permissionCapabilities.auto === true);
     if (state.visible === false || state.locked === true || state.globalPermissionModeForced === true || state.connected === false || store.get('connected') === false) return;
     if (!state.projectSlug || state.projectSlug !== store.get('currentSlug') || !state.sessionId) return;
-    if (mode === "auto" && (state.vendor !== "claude" || !autoSupported)) return;
+    if (mode === "auto" && !autoSupported) return;
     sendPermissionMode(state.projectSlug, state.sessionId, mode);
   });
 }

package/lib/public/modules/personal-settings-dialog.js

@@ -17,7 +17,13 @@ export function preparePersonalConnectionDialog(overlay, inline) {
     if (label && input) label.htmlFor = input.id;
   });
   enhanceSettingsSelects(overlay);
-  function markDirty() { dirty = true; if (inline) store.set({personalEmailDirty:true}); }
+  var fields = Array.from(overlay.querySelectorAll('input,select,textarea'));
+  function value(field) {return field.type === 'checkbox' ? field.checked : field.value;}
+  var baseline = fields.map(value);
+  function markDirty() {
+    dirty = fields.some(function (field, index) {return value(field) !== baseline[index];});
+    if (inline) store.set({personalEmailDirty:dirty});
+  }
   overlay.addEventListener('input', markDirty);
   overlay.addEventListener('change', markDirty);
   var unsubscribe = inline ? store.subscribe(function (state, previousState) {