clay-server 4.2.0-beta.1 → 4.2.0-beta.2

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

@@ -42,6 +42,8 @@ export function forwardPaneIssueReference(ref, projectSlug) {
   return true;
 }
 
+export { forwardPaneFileReference } from './pane-file-bridge.js';
+
 // Toggle without setContextView: panes use a transient override and must not
 // rewrite the user's server-persisted main-view preference.
 function togglePaneContextPanel() {

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

@@ -0,0 +1,69 @@
+import { store } from './store.js';
+
+function paneFrame(host, source) {
+  if (!host || !source) return null;
+  var frames = host.querySelectorAll(".split-pane-frame");
+  for (var i = 0; i < frames.length; i++) {
+    if (frames[i].contentWindow === source) return frames[i];
+  }
+  return null;
+}
+
+function matchingPane(frame, split) {
+  if (!frame || !split || !split.panes) return null;
+  for (var i = 0; i < split.panes.length; i++) {
+    var pane = split.panes[i];
+    if (String(pane.slug) === String(frame.dataset.projectSlug) && String(pane.sessionId) === String(frame.dataset.sessionId)) return pane;
+  }
+  return null;
+}
+
+function hasLivePaneSource(frame, pane) {
+  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; }
+}
+
+function validLocation(value) {
+  return value == null || (Number.isSafeInteger(value) && value > 0);
+}
+
+export function revealFilesPanel() {
+  var filesPanel = document.getElementById("sidebar-panel-files");
+  if (!filesPanel || !filesPanel.classList.contains("hidden")) return false;
+  var filesButton = document.getElementById("file-browser-btn");
+  if (!filesButton) return false;
+  filesButton.click();
+  return true;
+}
+
+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",
+    path: path,
+    line: opts && opts.line != null ? opts.line : null,
+    column: opts && opts.column != null ? opts.column : null,
+    projectSlug: opts && opts.projectSlug ? opts.projectSlug : store.get('currentSlug'),
+    sessionId: opts && opts.sessionId != null ? String(opts.sessionId) : (store.get('activeSessionId') != null ? String(store.get('activeSessionId')) : null),
+  }, window.location.origin);
+  return true;
+}
+
+export function handlePaneFileMessage(event, host, openFile, openFiles) {
+  if (!event || event.origin !== window.location.origin || !host) return false;
+  var msg = event.data;
+  if (!msg || msg.type !== "clay-pane-open-file") return false;
+  var frame = paneFrame(host, event.source);
+  var state = store.snap();
+  var pane = matchingPane(frame, state.splitPanes);
+  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;
+  // The frame/session association was validated above. The host browser owns
+  // the read, so do not apply the pane session as a host-session restriction;
+  // the normal authenticated project filesystem checks remain authoritative.
+  var result = openFile(msg.path, { line: msg.line, column: msg.column, projectSlug: msg.projectSlug });
+  if (result !== false && typeof openFiles === "function") openFiles();
+  return true;
+}

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

@@ -2,6 +2,12 @@ export function activeQueueItems(items) {
   return (items || []).filter(function (item) { return item.state === "pending" || item.state === "claimed"; });
 }
 
+export function hasFutureScheduledPending(items) {
+  items = items || [];
+  for (var i = 0; i < items.length; i++) if (items[i].state === "pending" && items[i].schedule && items[i].schedule.ready !== true) return true;
+  return false;
+}
+
 export function moveQueueId(ids, id, direction, targetId) {
   var next = (ids || []).slice();
   var from = next.indexOf(id);

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

@@ -0,0 +1,73 @@
+// Queue recovery keeps an authorized queue scope distinct from WebSocket transport.
+
+function sameId(a, b) { return String(a) === String(b); }
+
+export function emptyQueue() { return { projectSlug: null, sessionId: null, revision: 0, paused: false, items: [], loading: false, error: "" }; }
+
+export function queueContext(state) {
+  state = state || {};
+  var available = !!state.currentSlug && !!state.activeSessionId && state.activeSessionMode !== "tui" && !state.dmMode && !state.mateProjectSlug;
+  return {
+    connected: !!state.connected,
+    projectSlug: state.currentSlug || null,
+    sessionId: state.activeSessionId || null,
+    accountId: state.myUserId || "default",
+    available: available,
+    enabled: available && !!state.connected,
+  };
+}
+
+export function sameQueueContext(a, b) {
+  return !!a && !!b && a.projectSlug === b.projectSlug && sameId(a.sessionId, b.sessionId) && a.accountId === b.accountId;
+}
+
+export function queueScopeChanged(state, previous) {
+  var next = queueContext(state);
+  var prior = queueContext(previous);
+  return !sameQueueContext(next, prior) || next.available !== prior.available || !!state.isMultiUserMode !== !!previous.isMultiUserMode;
+}
+
+export function queueReconnected(state, previous) {
+  return !!state.connected && !previous.connected && !queueScopeChanged(state, previous);
+}
+
+export function queueCanRender(queue, target) {
+  return !!target && target.available && !!queue && queue.projectSlug === target.projectSlug && sameId(queue.sessionId, target.sessionId);
+}
+
+export function createQueueHydrationRecovery() {
+  var timer = null;
+  var requestId = null;
+  function clear(id) {
+    if (id && requestId !== id) return;
+    if (timer) clearTimeout(timer);
+    timer = null;
+    requestId = null;
+  }
+  return {
+    schedule: function (id, retry) {
+      clear();
+      requestId = id;
+      timer = setTimeout(function () {
+        timer = null;
+        requestId = null;
+        retry();
+      }, 10000);
+      if (timer && timer.unref) timer.unref();
+    },
+    clear: clear,
+  };
+}
+
+export function canonicalQueue(queue, result) {
+  if (queue && queue.projectSlug === result.projectSlug && sameId(queue.sessionId, result.sessionId) && Number(result.revision) < Number(queue.revision)) return null;
+  return {
+    projectSlug: result.projectSlug,
+    sessionId: result.sessionId,
+    revision: Number(result.revision) || 0,
+    paused: result.paused === true,
+    items: Array.isArray(result.items) ? result.items : queue.items || [],
+    loading: false,
+    error: "",
+  };
+}

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

@@ -2,77 +2,50 @@ import { store } from './store.js';
 import { getWs } from './ws-ref.js';
 import { escapeHtml } from './utils.js';
 import { refreshIcons } from './icons.js';
-import { activeQueueItems, moveQueueId, matchesQueueContext, canApplyQueueRevision } from './pending-message-queue-model.js';
+import { activeQueueItems, hasFutureScheduledPending, moveQueueId, matchesQueueContext, canApplyQueueRevision } from './pending-message-queue-model.js';
+import { emptyQueue, queueContext, sameQueueContext, queueScopeChanged, queueReconnected, queueCanRender, createQueueHydrationRecovery, canonicalQueue } from './pending-message-queue-recovery.js';
 import { imageSrc, imageDraft, openImagePreview, chooseImages } from './pending-message-image-editor.js';
 import { setScheduleBtnDisabled } from './scheduled-message-state.js';
 
+export { hasFutureScheduledPending };
 var queueEl = null;
 var initialized = false;
 var requestCounter = 0;
 var editGenerationCounter = 0;
-
-function emptyQueue() {
-  return { projectSlug: null, sessionId: null, revision: 0, paused: false, items: [], loading: false, error: "" };
-}
-
-function context() {
-  var state = store.snap();
-  return {
-    connected: !!state.connected,
-    projectSlug: state.currentSlug || null,
-    sessionId: state.activeSessionId || null,
-    accountId: state.myUserId || "default",
-    enabled: !!state.connected && !!state.currentSlug && !!state.activeSessionId && state.activeSessionMode !== "tui" && !state.dmMode && !state.mateProjectSlug,
-  };
-}
-
+var hydrationRecovery = createQueueHydrationRecovery();
+function context() { return queueContext(store.snap()); }
 function sameId(a, b) { return String(a) === String(b); }
-function sameContext(a, b) { return !!a && !!b && a.projectSlug === b.projectSlug && sameId(a.sessionId, b.sessionId) && a.accountId === b.accountId; }
+function sameContext(a, b) { return sameQueueContext(a, b); }
 function currentQueue() { return store.get('pendingMessageQueue') || emptyQueue(); }
-
 function isOwn(item) {
   if (!store.get('isMultiUserMode')) return true;
   return !!item && String(item.actorId) === String(store.get('myUserId'));
 }
-
-export function hasFutureScheduledPending(items) {
-  items = items || [];
-  for (var i = 0; i < items.length; i++) {
-    if (items[i].state === "pending" && items[i].schedule && items[i].schedule.ready !== true) return true;
-  }
-  return false;
-}
-
 function syncScheduleButton() {
   var target = context();
   var queue = currentQueue();
   var current = target.enabled && queue.projectSlug === target.projectSlug && sameId(queue.sessionId, target.sessionId);
   setScheduleBtnDisabled(current && hasFutureScheduledPending(queue.items));
 }
-
 function isEditableItem(id) {
   var items = currentQueue().items || [];
   for (var i = 0; i < items.length; i++) if (items[i].id === id) return items[i].state === "pending" && isOwn(items[i]);
   return false;
 }
-
 function send(message) {
   var socket = getWs();
   if (!socket || socket.readyState !== 1) return false;
-  socket.send(JSON.stringify(message));
-  return true;
+  try { socket.send(JSON.stringify(message)); return true; }
+  catch (e) { return false; }
 }
-
 function nextRequestId(kind) {
   requestCounter++;
   return "pending-" + kind + "-" + Date.now().toString(36) + "-" + requestCounter;
 }
-
 function nextEditGeneration() {
   editGenerationCounter++;
   return editGenerationCounter;
 }
-
 function updateEdit(update) {
   var edit = store.get('pendingMessageQueueEdit');
   if (!edit) return;
@@ -81,7 +54,6 @@ function updateEdit(update) {
   next.generation = nextEditGeneration();
   store.set({ pendingMessageQueueEdit: next });
 }
-
 function rememberRequest(kind, extra) {
   var requestId = nextRequestId(kind);
   var requests = Object.assign({}, store.get('pendingMessageQueueRequests') || {});
@@ -89,7 +61,6 @@ function rememberRequest(kind, extra) {
   store.set({ pendingMessageQueueRequests: requests });
   return requestId;
 }
-
 function forgetRequest(requestId) {
   var requests = Object.assign({}, store.get('pendingMessageQueueRequests') || {});
   var request = requests[requestId] || null;
@@ -97,15 +68,33 @@ function forgetRequest(requestId) {
   store.set({ pendingMessageQueueRequests: requests });
   return request;
 }
+function scheduleHydrationRetry(requestId) {
+  hydrationRecovery.schedule(requestId, function () {
+    var requests = store.get('pendingMessageQueueRequests') || {};
+    if (!requests[requestId] || !sameContext(requests[requestId].context, context()) || !context().enabled) return;
+    forgetRequest(requestId);
+    store.set({ pendingMessageQueue: Object.assign({}, currentQueue(), { loading: false, error: "Queue refresh timed out. Retrying…" }) });
+    requestPendingMessages(true);
+  });
+}
 
+function retryHydration() {
+  hydrationRecovery.schedule("retry", function () { if (context().enabled) requestPendingMessages(true); });
+}
 export function requestPendingMessages(preserveError) {
   var target = context();
   if (!target.enabled) return false;
   var requestId = rememberRequest("get");
-  store.set({ pendingMessageQueue: Object.assign({}, currentQueue(), { projectSlug: target.projectSlug, sessionId: target.sessionId, loading: true, error: preserveError ? currentQueue().error : "" }) });
-  return send({ type: "pending_message_get", projectSlug: target.projectSlug, sessionId: target.sessionId, requestId: requestId });
+  store.set({ pendingMessageQueue: Object.assign({}, currentQueue(), { projectSlug: target.projectSlug, sessionId: target.sessionId, loading: true, error: preserveError ? currentQueue().error : "" }), pendingMessageQueueRecovery: true });
+  if (!send({ type: "pending_message_get", projectSlug: target.projectSlug, sessionId: target.sessionId, requestId: requestId })) {
+    forgetRequest(requestId);
+    store.set({ pendingMessageQueue: Object.assign({}, currentQueue(), { loading: false, error: "Queue connection unavailable" }) });
+    retryHydration();
+    return false;
+  }
+  scheduleHydrationRetry(requestId);
+  return true;
 }
-
 function sendMutation(kind, fields) {
   var target = context();
   var queue = currentQueue();
@@ -131,7 +120,6 @@ function sendMutation(kind, fields) {
   }
   return true;
 }
-
 function sendScheduledNow(id) {
   var target = context();
   var queue = currentQueue();
@@ -153,19 +141,12 @@ function scheduledTimeLabel(notBefore) {
 
 function applyCanonical(result) {
   var target = context();
-  if (!result || result.projectSlug !== target.projectSlug || !sameId(result.sessionId, target.sessionId)) return false;
+  if (!target.available || !result || result.projectSlug !== target.projectSlug || !sameId(result.sessionId, target.sessionId)) return false;
   var queue = currentQueue();
-  if (queue.projectSlug === result.projectSlug && sameId(queue.sessionId, result.sessionId) && !canApplyQueueRevision(queue.revision, result.revision)) return false;
+  var nextQueue = canonicalQueue(queue, result);
+  if (!nextQueue) return false;
   var nextEdit = editAfterQueueTransition(Array.isArray(result.items) ? result.items : queue.items || []);
-  var update = { pendingMessageQueue: {
-    projectSlug: result.projectSlug,
-    sessionId: result.sessionId,
-    revision: Number(result.revision) || 0,
-    paused: result.paused === true,
-    items: Array.isArray(result.items) ? result.items : queue.items || [],
-    loading: false,
-    error: "",
-  } };
+  var update = { pendingMessageQueueRecovery: false, pendingMessageQueue: nextQueue };
   if (nextEdit) update.pendingMessageQueueEdit = nextEdit;
   store.set(update);
   return true;
@@ -192,20 +173,26 @@ export function handlePendingMessageQueueMessage(msg) {
   var types = ["pending_message_result", "message_queued", "pending_message_queued", "pending_message_state", "pending_message_claimed", "pending_message_consumed"];
   if (!msg || types.indexOf(msg.type) < 0) return false;
   var target = context();
+  if (!target.available) return true;
   if (msg.type === "pending_message_result") {
     var request = forgetRequest(msg.requestId);
+    if (request && request.kind === "get") hydrationRecovery.clear(msg.requestId);
     if (!request || !sameContext(request.context, target)) return true;
     var result = msg.result || {};
-    if (!matchesQueueContext(result, target.projectSlug, target.sessionId)) return true;
+    if (!matchesQueueContext(result, target.projectSlug, target.sessionId)) {
+      if (request.kind === "get") retryHydration();
+      return true;
+    }
     if (!result.ok) {
       if (request.kind === "get") {
         store.set({ pendingMessageQueue: Object.assign({}, currentQueue(), { loading: false, error: result.error || "Queue update failed" }) });
+        retryHydration();
         return true;
       }
       conflict(request, result.error || "Queue update failed");
       return true;
     }
-    applyCanonical(result);
+    if (!applyCanonical(result) && request.kind === "get") retryHydration();
     if (request.kind === "edit") {
       var currentEdit = store.get('pendingMessageQueueEdit');
       if (currentEdit && currentEdit.id === request.itemId && currentEdit.text === request.editText && (!Object.prototype.hasOwnProperty.call(request, "editImages") || JSON.stringify(currentEdit.images || []) === request.editImages) && currentEdit.generation === request.editGeneration) {
@@ -339,10 +326,12 @@ function renderItem(item, index) {
   var attachment = attachmentLabel(item);
   var scheduled = item.schedule && item.schedule.jobId;
   var futureScheduled = scheduled && item.schedule.ready !== true;
+  var controlsDisabled = !context().enabled;
+  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) + '">';
   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">' + '<i data-lucide="grip-vertical"></i></button>';
+  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>';
   html += '<div class="pending-message-content">';
   if (isEditing) {
@@ -356,7 +345,7 @@ function renderItem(item, index) {
     html += '<button type="button" class="pending-message-add-image" data-action="add-image"' + (editing.pendingReads ? ' disabled' : '') + '>+ Add images</button></div>';
     if (editing.pendingReads) html += '<div class="pending-message-image-reading">Reading image…</div>';
     if (editing.error) html += '<div class="pending-message-error" role="alert">' + escapeHtml(editing.error) + '</div>';
-    html += '<div class="pending-message-edit-actions"><button type="button" data-action="edit-cancel">Cancel</button><button type="button" class="is-primary" data-action="edit-save"' + (editing.pendingReads ? ' disabled' : '') + '>Save</button></div>';
+    html += '<div class="pending-message-edit-actions"><button type="button" data-action="edit-cancel">Cancel</button><button type="button" class="is-primary" data-action="edit-save"' + (editing.pendingReads || !context().enabled ? ' disabled' : '') + '>Save</button></div>';
   } else {
     html += '<div class="pending-message-preview" title="' + escapeHtml(text) + '">' + escapeHtml(text) + '</div>';
     if (item.message && item.message.images && item.message.images.length) {
@@ -371,9 +360,9 @@ function renderItem(item, index) {
     if (scheduled) html += '<div class="pending-message-schedule-meta"><i data-lucide="clock-3"></i><span>' + escapeHtml(futureScheduled ? scheduledTimeLabel(item.schedule.notBefore) : "Ready to send") + '</span></div>';
   }
   html += '</div><div class="pending-message-actions">';
-  if (!isEditing && own && item.state === "pending") html += '<button type="button" data-action="edit" aria-label="Edit queued message" title="Edit"><i data-lucide="pencil"></i></button>';
-  if (!isEditing && own && item.state === "pending" && futureScheduled) html += '<button type="button" data-action="send-now" aria-label="Send scheduled message now" title="Send now"><i data-lucide="send"></i></button>';
-  if (!isEditing && own) html += '<button type="button" data-action="cancel" aria-label="Cancel queued message" title="Cancel"><i data-lucide="x"></i></button>';
+  if (!isEditing && own && item.state === "pending") html += '<button type="button" data-action="edit" aria-label="Edit queued message" title="Edit"' + disabled + '><i data-lucide="pencil"></i></button>';
+  if (!isEditing && own && item.state === "pending" && futureScheduled) html += '<button type="button" data-action="send-now" aria-label="Send scheduled message now" title="Send now"' + disabled + '><i data-lucide="send"></i></button>';
+  if (!isEditing && own) html += '<button type="button" data-action="cancel" aria-label="Cancel queued message" title="Cancel"' + disabled + '><i data-lucide="x"></i></button>';
   html += '</div></div>';
   return html;
 }
@@ -386,12 +375,15 @@ function render() {
   var queue = currentQueue();
   var items = activeQueueItems(queue.items);
   var focus = captureFocus();
-  var visible = target.enabled && queue.projectSlug === target.projectSlug && sameId(queue.sessionId, target.sessionId) && items.length > 0;
+  var recovering = !!store.get('pendingMessageQueueRecovery');
+  var visible = queueCanRender(queue, target) && (items.length > 0 || queue.loading || recovering || !!queue.error);
   queueEl.classList.toggle("hidden", !visible);
   if (!visible) { queueEl.innerHTML = ""; return; }
   var html = '<div class="pending-message-head"><div><span class="pending-message-eyebrow">Next up</span><span class="pending-message-count">' + items.length + '</span></div>';
-  if (queue.paused) html += '<button type="button" class="pending-message-resume" data-action="resume"><i data-lucide="play"></i><span>Resume queue</span></button>';
+  if (queue.paused) html += '<button type="button" class="pending-message-resume" data-action="resume"' + (target.enabled ? '' : ' disabled aria-disabled="true"') + '><i data-lucide="play"></i><span>Resume queue</span></button>';
   html += '</div>';
+  if (!target.connected) html += '<div class="pending-message-restoring" role="status">Connection lost. Queue changes are unavailable.</div>';
+  else if (queue.loading || recovering) html += '<div class="pending-message-restoring" role="status">Restoring queued messages…</div>';
   if (queue.error) html += '<div class="pending-message-banner-error" role="alert">' + escapeHtml(queue.error) + '</div>';
   html += '<div class="pending-message-list">';
   for (var i = 0; i < items.length; i++) html += renderItem(items[i], i);
@@ -474,18 +466,29 @@ export function initPendingMessageQueue() {
   queueEl = document.getElementById("pending-message-queue");
   if (!queueEl) return;
   bindEvents();
+  var initialTarget = context();
+  if (initialTarget.available && !queueCanRender(currentQueue(), initialTarget)) store.set({ pendingMessageQueue: Object.assign({}, emptyQueue(), { projectSlug: initialTarget.projectSlug, sessionId: initialTarget.sessionId }), pendingMessageQueueRecovery: true });
   store.subscribe(function (state, previous) {
-    var contextChanged = state.connected !== previous.connected || state.currentSlug !== previous.currentSlug || state.activeSessionId !== previous.activeSessionId || state.activeSessionMode !== previous.activeSessionMode || state.dmMode !== previous.dmMode || state.mateProjectSlug !== previous.mateProjectSlug || state.myUserId !== previous.myUserId || state.isMultiUserMode !== previous.isMultiUserMode;
-    if (contextChanged) {
-      store.set({ pendingMessageQueue: emptyQueue(), pendingMessageQueueRequests: {}, pendingMessageQueueEdit: null, pendingMessageQueueDrag: null, pendingMessageQueueFocusReturn: null });
+    if (queueScopeChanged(state, previous)) {
+      hydrationRecovery.clear();
+      store.set({ pendingMessageQueue: emptyQueue(), pendingMessageQueueRecovery: false, pendingMessageQueueRequests: {}, pendingMessageQueueEdit: null, pendingMessageQueueDrag: null, pendingMessageQueueFocusReturn: null });
       setScheduleBtnDisabled(false);
       if (context().enabled) requestPendingMessages();
       return;
     }
+    if (queueReconnected(state, previous)) {
+      hydrationRecovery.clear();
+      store.set({ pendingMessageQueueRequests: {} });
+      requestPendingMessages();
+      render();
+      return;
+    }
+    if (state.connected !== previous.connected) { render(); return; }
     var edit = state.pendingMessageQueueEdit;
     var previousEdit = previous.pendingMessageQueueEdit;
     var editNeedsRender = edit !== previousEdit && (!edit || !previousEdit || edit.id !== previousEdit.id || edit.error !== previousEdit.error || edit.images !== previousEdit.images || edit.pendingReads !== previousEdit.pendingReads);
     if (state.pendingMessageQueue !== previous.pendingMessageQueue || editNeedsRender) render();
   });
   render();
+  if (context().enabled) requestPendingMessages();
 }

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

@@ -0,0 +1,187 @@
+// Shared session permission selector for standalone and split Driver headers.
+
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { showToast } from './utils.js';
+
+var REQUEST_TIMEOUT_MS = 10000;
+var requestTimers = {};
+
+function targetKey(projectSlug, sessionId) {
+  return String(projectSlug || "") + ":" + String(sessionId || "");
+}
+
+function pendingMap() {
+  return store.get('permissionModePendingByTarget') || {};
+}
+
+export function permissionPendingFor(projectSlug, sessionId) {
+  return pendingMap()[targetKey(projectSlug, sessionId)] || null;
+}
+
+function replacePending(key, value) {
+  var next = Object.assign({}, pendingMap());
+  if (value) next[key] = value;
+  else delete next[key];
+  store.set({ permissionModePendingByTarget: next });
+}
+
+function clearRequest(requestId, key) {
+  if (requestTimers[requestId]) clearTimeout(requestTimers[requestId]);
+  delete requestTimers[requestId];
+  var pending = pendingMap()[key];
+  if (pending && pending.requestId === requestId) replacePending(key, null);
+}
+
+export function clearPermissionModePending() {
+  var ids = Object.keys(requestTimers);
+  for (var i = 0; i < ids.length; i++) clearTimeout(requestTimers[ids[i]]);
+  requestTimers = {};
+  store.set({ permissionModePendingByTarget: {} });
+}
+
+export function createPermissionControl(className, ariaLabel) {
+  var control = document.createElement("div");
+  control.className = "session-permission-control " + (className || "");
+  control.setAttribute("role", "group");
+  control.setAttribute("aria-label", ariaLabel || "Session permission mode");
+  control.innerHTML = '<div class="session-permission-segmented">' +
+    '<button type="button" data-permission-mode="default">Ask</button>' +
+    '<button type="button" data-permission-mode="auto">Auto</button>' +
+    '<button type="button" data-permission-mode="bypassPermissions" aria-label="Skip permissions"><span class="permission-label-long">Skip permissions</span><span class="permission-label-short" aria-hidden="true">Skip</span></button>' +
+    '</div><span class="session-permission-status" aria-live="polite"></span>';
+  return control;
+}
+
+function modeLabel(mode) {
+  var labels = { default: "Ask", plan: "Plan", acceptEdits: "Auto-accept edits", dontAsk: "Don't ask",
+    bypassPermissions: "Skip permissions", auto: "Auto" };
+  return labels[mode] || mode;
+}
+
+export function permissionStatusText(state, pending, autoSupported, autoVisible) {
+  if (state.globalPermissionModeForced) return "Skip permissions forced by the server setting";
+  if (pending) return "Applying…";
+  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 (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);
+  }
+  return "";
+}
+
+function compactPermissionStatusText(state, pending, autoSupported, autoVisible, fullText) {
+  if (state.globalPermissionModeForced) return "Forced Skip";
+  if (pending) return "Applying…";
+  if (state.permissionMode === "plan") return "Plan";
+  if (state.permissionMode === "acceptEdits") return "Auto-accept";
+  if (state.permissionMode === "dontAsk") return "Don't ask";
+  if (autoVisible && !autoSupported) return "Auto unavailable";
+  if (state.permissionMode === "auto" && !state.effectivePermissionMode) return "Waiting for Auto";
+  if (state.permissionMode === "auto" && state.effectivePermissionMode !== "auto") return "Using " + modeLabel(state.effectivePermissionMode);
+  return fullText;
+}
+
+export function renderPermissionControl(control, state) {
+  if (!control) return;
+  var projectSlug = state.projectSlug || "";
+  var sessionId = state.sessionId || null;
+  var pending = permissionPendingFor(projectSlug, sessionId);
+  var autoVisible = state.vendor === "claude";
+  var autoSupported = !!(state.permissionCapabilities && state.permissionCapabilities.auto === true);
+  var globallyForced = state.globalPermissionModeForced === true;
+  var connected = state.connected !== false && !!getWs() && getWs().readyState === 1;
+  control.classList.toggle("hidden", state.visible === false);
+  control.classList.toggle("permission-pending", !!pending);
+  control.classList.toggle("permission-auto-unsupported", autoVisible && !autoSupported);
+  control.classList.toggle("permission-globally-forced", globallyForced);
+  control.classList.toggle("permission-runtime-fallback", state.permissionMode === "auto" && !!state.effectivePermissionMode && state.effectivePermissionMode !== "auto");
+  var buttons = control.querySelectorAll("[data-permission-mode]");
+  for (var i = 0; i < buttons.length; i++) {
+    var mode = buttons[i].dataset.permissionMode;
+    var unsupported = mode === "auto" && autoVisible && !autoSupported;
+    buttons[i].hidden = mode === "auto" && !autoVisible;
+    var selected = globallyForced ? mode === "bypassPermissions" : mode === state.permissionMode;
+    buttons[i].disabled = globallyForced || unsupported || !!pending || !connected || state.locked === true;
+    buttons[i].classList.toggle("active", selected);
+    buttons[i].setAttribute("aria-pressed", selected ? "true" : "false");
+    if (unsupported) buttons[i].title = "Auto permissions are unavailable for this Claude session.";
+    else buttons[i].removeAttribute("title");
+  }
+  var status = control.querySelector(".session-permission-status");
+  if (status) {
+    var fullStatus = permissionStatusText(state, pending, autoSupported, autoVisible);
+    var compact = control.classList.contains("split-pane-full-access");
+    status.textContent = compact ? compactPermissionStatusText(state, pending, autoSupported, autoVisible, fullStatus) : fullStatus;
+    status.classList.toggle("hidden", !status.textContent);
+    if (fullStatus) status.title = fullStatus;
+    else status.removeAttribute("title");
+  }
+}
+
+export function bindPermissionControl(control, getState) {
+  if (!control || control.dataset.permissionBound === "true") return;
+  control.dataset.permissionBound = "true";
+  control.addEventListener("click", function(event) {
+    var button = event.target.closest("[data-permission-mode]");
+    if (!button || button.disabled) return;
+    var state = getState() || {};
+    var mode = button.dataset.permissionMode;
+    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;
+    sendPermissionMode(state.projectSlug, state.sessionId, mode);
+  });
+}
+
+export function sendPermissionMode(projectSlug, sessionId, mode) {
+  var ws = getWs();
+  if (store.get('skipPermsEnabled') === true) {
+    showToast("Skip permissions is forced by the server setting.", "error");
+    return false;
+  }
+  if (!projectSlug || !sessionId || !ws || ws.readyState !== 1) {
+    showToast("Permission mode could not be changed while disconnected.", "error");
+    return false;
+  }
+  var key = targetKey(projectSlug, sessionId);
+  if (permissionPendingFor(projectSlug, sessionId)) return false;
+  var requestId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : String(Date.now()) + ":" + String(sessionId);
+  replacePending(key, { requestId: requestId, projectSlug: projectSlug, sessionId: sessionId, mode: mode });
+  requestTimers[requestId] = setTimeout(function() {
+    clearRequest(requestId, key);
+    showToast("Permission mode change timed out. The previous mode is still shown.", "error");
+  }, REQUEST_TIMEOUT_MS);
+  try {
+    var sendResult = ws.send(JSON.stringify({ type: "set_permission_mode", projectSlug: projectSlug, sessionId: sessionId, mode: mode, requestId: requestId }));
+    if (sendResult === false) throw new Error("The permission transport declined the request.");
+  } catch (error) {
+    clearRequest(requestId, key);
+    showToast("Permission mode could not be sent: " + (error.message || error), "error");
+    return false;
+  }
+  return true;
+}
+
+export function handlePermissionModeResult(msg) {
+  var key = targetKey(msg.projectSlug, msg.sessionId);
+  var pending = pendingMap()[key];
+  if (!pending || pending.requestId !== msg.requestId) return;
+  clearRequest(msg.requestId, key);
+  if (!msg.ok) {
+    showToast(msg.error || "Permission mode could not be changed.", "error");
+    return;
+  }
+  if (msg.projectSlug === store.get('currentSlug') && msg.sessionId === store.get('activeSessionId')) {
+    store.set({
+      currentMode: msg.mode || "default",
+      effectivePermissionMode: Object.prototype.hasOwnProperty.call(msg, 'effectivePermissionMode') ? msg.effectivePermissionMode : null,
+      permissionCapabilities: msg.permissionCapabilities || store.get('permissionCapabilities'),
+      mcpPermissionModeOverrides: msg.mcpPermissionModeOverrides || {},
+    });
+  }
+}