codex-overleaf-link 1.9.10 → 1.9.12

package/extension/src/content/projectSettingsCoordinator.js

@@ -0,0 +1,365 @@
+(function initCodexOverleafProjectSettingsCoordinator() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      CodexOverleafTheme,
+      GovernanceRules,
+      SettingsPanel,
+      closeContextTray,
+      closeDiagnosticsMenu,
+      closeDiagnosticsResult,
+      closeModelConfigPopover,
+      closeSlashMenu,
+      getCurrentProjectId,
+      getLocalSkillsPanel,
+      getLocale,
+      getPanel,
+      getPanelRendererInstance,
+      getSettingsPanelInstance,
+      getState,
+      isProjectEditorRoute,
+      refreshStorageUsageSummary,
+      renderAuditHistoryPanel,
+      renderRecentProjectsVariant,
+      saveStateSoon,
+      setState,
+      tr,
+      tx,
+      window
+    } = deps;
+    let customInstructionsEditorProjectId = '';
+    let customInstructionsEditorValue = '';
+    let themeAutoDisposer = null;
+
+    function normalizeCustomInstructionsByProject(value) {
+      const result = {};
+      const textMaxChars = 12000;
+      const keyMaxChars = 160;
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return result;
+      }
+      for (const rawKey of Object.keys(value)) {
+        const key = typeof rawKey === 'string' ? rawKey.trim() : '';
+        if (!key) {
+          continue;
+        }
+        const normalizedKey = key.length <= keyMaxChars ? key : key.slice(0, keyMaxChars - 1) + '…';
+        const rawText = typeof value[rawKey] === 'string' ? value[rawKey] : '';
+        result[normalizedKey] = rawText.length <= textMaxChars
+          ? rawText
+          : rawText.slice(0, textMaxChars - 1) + '…';
+      }
+      return result;
+    }
+
+    function getCustomInstructionsForCurrentProject() {
+      const projectId = getCurrentProjectId();
+      const normalizedProject = normalizeCustomInstructionsByProject({ [projectId]: '' });
+      const normalizedProjectId = Object.keys(normalizedProject)[0] || '';
+      if (!normalizedProjectId) {
+        return '';
+      }
+      return normalizeCustomInstructionsByProject(getState()?.customInstructionsByProject)[normalizedProjectId] || '';
+    }
+
+    function setCustomInstructionsForProject(projectId, value) {
+      const normalizedProject = normalizeCustomInstructionsByProject({ [projectId]: value });
+      const normalizedProjectId = Object.keys(normalizedProject)[0] || '';
+      if (!normalizedProjectId) {
+        return;
+      }
+      setState({
+        ...getState(),
+        customInstructionsByProject: {
+          ...normalizeCustomInstructionsByProject(getState()?.customInstructionsByProject),
+          [normalizedProjectId]: normalizedProject[normalizedProjectId]
+        }
+      });
+    }
+
+    function openCustomInstructionsSettings() {
+      const settingsPanelInstance = getSettingsPanelInstance();
+      if (!settingsPanelInstance) {
+        return;
+      }
+      closeDiagnosticsMenu();
+      closeDiagnosticsResult();
+      closeModelConfigPopover();
+      closeContextTray();
+      closeSlashMenu();
+      clearProjectSettingsStatus();
+      syncCustomInstructionsEditorForProject(getCurrentProjectId(), { force: true });
+      syncProjectSettingsEditorForProject();
+      getPanelRendererInstance()?.setView?.('settings');
+      SettingsPanel.show(settingsPanelInstance);
+      refreshStorageUsageSummary();
+      if (settingsPanelInstance.container?.querySelector('[data-history-card]')?.open) {
+        renderAuditHistoryPanel();
+      }
+      refreshLocalSkills().catch(error => setProjectSettingsStatus(tx(
+        `Could not list local skills: ${error.message}`,
+        `无法列出本地技能：${error.message}`
+      ), 'failed'));
+    }
+
+    function toggleCustomInstructionsSettings() {
+      if (SettingsPanel.isVisible(getSettingsPanelInstance())) {
+        closeCustomInstructionsSettings();
+        return;
+      }
+      openCustomInstructionsSettings();
+    }
+
+    function closeCustomInstructionsSettings() {
+      SettingsPanel.hide(getSettingsPanelInstance());
+      if (isProjectEditorRoute(window.location)) {
+        getPanelRendererInstance()?.setView?.('session');
+      } else {
+        renderRecentProjectsVariant().catch(() => { /* swallow */ });
+      }
+    }
+
+    function openSkillsView() {
+      if (!getSettingsPanelInstance()) {
+        return;
+      }
+      getPanelRendererInstance()?.setView?.('skills');
+      refreshLocalSkills().catch(error => setProjectSettingsStatus(tx(
+        `Could not list local skills: ${error.message}`,
+        `无法列出本地技能：${error.message}`
+      ), 'failed'));
+    }
+
+    function closeSkillsView() {
+      getPanelRendererInstance()?.setView?.('settings');
+    }
+
+    function updateSkillsEntrySummary() {
+      const settingsPanelInstance = getSettingsPanelInstance();
+      if (!settingsPanelInstance) {
+        return;
+      }
+      const summary = getSkillLoadingSettings().loadCodexOverleafSkills === false
+        ? tr('codexOverleafSkillsSummaryOff')
+        : tr('codexOverleafSkillsSummaryCount', { count: countEnabledCodexOverleafSkills() });
+      SettingsPanel.setSkillsSummary(settingsPanelInstance, summary);
+    }
+
+    function countEnabledCodexOverleafSkills() {
+      const skills = Array.isArray(getState()?.codexOverleafSkills) ? getState().codexOverleafSkills : [];
+      return skills.reduce((total, skill) => {
+        const id = String(skill?.id || '').trim();
+        return id && isCodexOverleafSkillEnabled(id) ? total + 1 : total;
+      }, 0);
+    }
+
+    function syncCustomInstructionsEditorForProject(projectId = getCurrentProjectId(), options) {
+      const syncOptions = options || {};
+      const panel = getPanel();
+      const input = panel?.querySelector('[data-custom-instructions-input]');
+      if (!input) {
+        return;
+      }
+      const normalizedProject = normalizeCustomInstructionsByProject({ [projectId]: '' });
+      const normalizedProjectId = Object.keys(normalizedProject)[0] || '';
+      const storedValue = normalizedProjectId
+        ? normalizeCustomInstructionsByProject(getState()?.customInstructionsByProject)[normalizedProjectId] || ''
+        : '';
+      input.placeholder = tr('customInstructionsPlaceholder');
+      const editorIsOpen = panel?.dataset?.view === 'settings' || panel?.dataset?.view === 'skills';
+      const editorIsDirty = normalizedProjectId
+        && customInstructionsEditorProjectId === normalizedProjectId
+        && input.value !== customInstructionsEditorValue;
+      if (!syncOptions.force && editorIsOpen && editorIsDirty) {
+        return;
+      }
+      input.value = storedValue;
+      customInstructionsEditorProjectId = normalizedProjectId;
+      customInstructionsEditorValue = storedValue;
+    }
+
+    function normalizeGovernanceRulesByProject(value) {
+      const result = {};
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return result;
+      }
+      for (const rawKey of Object.keys(value)) {
+        const key = normalizeProjectPreferenceKey(rawKey);
+        if (!key) {
+          continue;
+        }
+        result[key] = normalizeGovernanceRules(value[rawKey]);
+      }
+      return result;
+    }
+
+    function normalizeProjectPreferenceKey(value) {
+      const text = String(value || '').trim();
+      return text.length <= 160 ? text : text.slice(0, 159) + '…';
+    }
+
+    function normalizeGovernanceRules(value = {}) {
+      if (GovernanceRules?.normalizeGovernanceRules) {
+        return GovernanceRules.normalizeGovernanceRules(value);
+      }
+      return {
+        readonlyPatterns: normalizePatternTextList(value.readonlyPatterns),
+        writablePatterns: normalizePatternTextList(value.writablePatterns),
+        sensitiveCheckEnabled: value.sensitiveCheckEnabled !== false,
+        sensitiveConfirmAllowed: value.sensitiveConfirmAllowed === true
+      };
+    }
+
+    function normalizePatternTextList(value) {
+      if (Array.isArray(value)) {
+        return value.map(item => String(item || '').trim()).filter(Boolean);
+      }
+      return String(value || '').split(/\r?\n/).map(item => item.trim()).filter(Boolean);
+    }
+
+    function getGovernanceRulesForCurrentProject() {
+      const projectId = normalizeProjectPreferenceKey(getCurrentProjectId());
+      return normalizeGovernanceRulesByProject(getState()?.governanceRulesByProject)[projectId]
+        || normalizeGovernanceRules({});
+    }
+
+    function setGovernanceRulesForCurrentProject(rules) {
+      const projectId = normalizeProjectPreferenceKey(getCurrentProjectId());
+      if (!projectId) {
+        return;
+      }
+      setState({
+        ...getState(),
+        governanceRulesByProject: {
+          ...normalizeGovernanceRulesByProject(getState()?.governanceRulesByProject),
+          [projectId]: normalizeGovernanceRules(rules)
+        }
+      });
+    }
+
+    function getThemePreference() {
+      return CodexOverleafTheme.normalizeThemePreference(getState()?.theme);
+    }
+
+    function applyPanelTheme(preference) {
+      const normalized = CodexOverleafTheme.normalizeThemePreference(preference);
+      CodexOverleafTheme.applyTheme(normalized, getPanel());
+      if (themeAutoDisposer) {
+        themeAutoDisposer();
+        themeAutoDisposer = null;
+      }
+      themeAutoDisposer = CodexOverleafTheme.watchAuto(normalized, getPanel());
+    }
+
+    function getSkillLoadingSettings() {
+      return {
+        loadCodexLocalSkills: getState()?.loadCodexLocalSkills !== false,
+        loadCodexOverleafSkills: getState()?.loadCodexOverleafSkills !== false
+      };
+    }
+
+    function setSkillLoadingSettings(settings = {}) {
+      setState({
+        ...getState(),
+        loadCodexLocalSkills: settings.loadCodexLocalSkills !== false,
+        loadCodexOverleafSkills: settings.loadCodexOverleafSkills !== false
+      });
+    }
+
+    function getCodexOverleafSkillEnabled() {
+      const map = getState()?.codexOverleafSkillEnabled;
+      return map && typeof map === 'object' && !Array.isArray(map) ? map : {};
+    }
+
+    function isCodexOverleafSkillEnabled(skillId) {
+      const map = getCodexOverleafSkillEnabled();
+      if (!Object.prototype.hasOwnProperty.call(map, skillId)) {
+        return true;
+      }
+      return map[skillId] !== false;
+    }
+
+    function setCodexOverleafSkillEnabled(skillId, enabled) {
+      const map = getCodexOverleafSkillEnabled();
+      setState({
+        ...getState(),
+        codexOverleafSkillEnabled: {
+          ...map,
+          [skillId]: Boolean(enabled)
+        }
+      });
+      saveStateSoon();
+      renderLocalSkillList();
+    }
+
+    function readSkillLoadingSettingsFromSettings() {
+      return SettingsPanel.readState(getSettingsPanelInstance()).skillToggles;
+    }
+
+    function readGovernanceRulesFromSettings() {
+      return normalizeGovernanceRules(SettingsPanel.readState(getSettingsPanelInstance()).governanceRules);
+    }
+
+    function syncProjectSettingsEditorForProject() {
+      SettingsPanel.loadState(getSettingsPanelInstance(), {
+        governanceRules: getGovernanceRulesForCurrentProject(),
+        skillToggles: getSkillLoadingSettings(),
+        theme: getThemePreference(),
+        language: getLocale()
+      });
+      renderLocalSkillList();
+    }
+
+    function setProjectSettingsStatus(text, status = 'info') {
+      SettingsPanel.setStatus(getSettingsPanelInstance(), text, status);
+    }
+
+    function clearProjectSettingsStatus() {
+      SettingsPanel.clearStatus(getSettingsPanelInstance());
+    }
+
+    async function refreshLocalSkills() {
+      return getLocalSkillsPanel().refreshLocalSkills();
+    }
+
+    function renderLocalSkillList() {
+      getLocalSkillsPanel().renderLocalSkillList();
+      updateSkillsEntrySummary();
+    }
+
+    return {
+      applyPanelTheme,
+      clearProjectSettingsStatus,
+      closeCustomInstructionsSettings,
+      closeSkillsView,
+      getCodexOverleafSkillEnabled,
+      getCustomInstructionsForCurrentProject,
+      getGovernanceRulesForCurrentProject,
+      getSkillLoadingSettings,
+      getThemePreference,
+      isCodexOverleafSkillEnabled,
+      normalizeCustomInstructionsByProject,
+      normalizeGovernanceRules,
+      normalizeGovernanceRulesByProject,
+      normalizeProjectPreferenceKey,
+      openCustomInstructionsSettings,
+      openSkillsView,
+      readGovernanceRulesFromSettings,
+      readSkillLoadingSettingsFromSettings,
+      refreshLocalSkills,
+      renderLocalSkillList,
+      setCodexOverleafSkillEnabled,
+      setCustomInstructionsForProject,
+      setGovernanceRulesForCurrentProject,
+      setProjectSettingsStatus,
+      setSkillLoadingSettings,
+      syncCustomInstructionsEditorForProject,
+      syncProjectSettingsEditorForProject,
+      toggleCustomInstructionsSettings,
+      updateSkillsEntrySummary
+    };
+  }
+
+  window.CodexOverleafProjectSettingsCoordinator = { create };
+})();

package/extension/src/content/sessionManager.js

@@ -12,7 +12,7 @@
     deriveSessionTitle
   } = window.CodexOverleafSessionState;
 
-  // Session manager — the session lifecycle + list/rename/delete surface
+  // Session manager — the session lifecycle + list/delete surface
   // carved out of contentRuntime.js (v1.4.7 structural-debt phase 3). Code
   // moved verbatim except that mutable runtime state is read through
   // getState()/getPanel()/getSessionPanelInstance() and written back through
@@ -35,210 +35,26 @@
       formatSessionTime
     } = deps;
 
-  function applySessionLabel() {
-    const trigger = getPanel().querySelector('[data-session-menu-trigger]');
-    if (trigger) {
-      trigger.title = tr('sessionMenuOpen');
-      trigger.setAttribute('aria-label', tr('sessionMenuOpen'));
-    }
-    const textNode = getPanel().querySelector('[data-session-label-text]');
-    const deleteButton = getPanel().querySelector('[data-session-delete]');
-    const renameButton = getPanel().querySelector('[data-session-rename]');
-    const renameInput = getPanel().querySelector('[data-session-rename-input]');
-    const active = getActiveSession(getState());
-    if (textNode) {
-      // Always show a title — fall back to the New Session placeholder for an
-      // empty active session (which has no list row), so the session you are in
-      // is never blank and unmanageable from the header.
-      textNode.textContent = active && isDisplayableSession(active)
-        ? getSessionDisplayTitle(active)
-        : tr('newSessionFallback');
-    }
-    if (deleteButton) {
-      const running = active ? isSessionRunning(active) : false;
-      // Deleting the sole empty session is a documented no-op (it would just
-      // mint another empty), so disable it rather than leave a dead click.
-      const soleEmpty = Boolean(active) && !isDisplayableSession(active) && (getState()?.sessions || []).length <= 1;
-      deleteButton.disabled = !active || running || soleEmpty;
-      deleteButton.title = running ? tr('deleteRunningSession') : tr('deleteSession');
-      deleteButton.setAttribute('aria-label', running ? tr('deleteRunningSession') : tr('deleteSession'));
-    }
-    if (renameButton) {
-      renameButton.title = tr('renameSession');
-      renameButton.setAttribute('aria-label', tr('renameSession'));
-    }
-    renameInput?.setAttribute('aria-label', tr('renameSession'));
-  }
-
-  // Wire the active-session header bar once (rename + delete act on the active
-  // session, reusing the same paths as the per-row controls).
-  function bindActiveSessionHeader() {
-    getPanel().querySelector('[data-session-delete]')?.addEventListener('click', event => {
-      event.stopPropagation();
-      if (getState()?.activeSessionId) {
-        deleteSessionWithConfirm(getState().activeSessionId);
-      }
-    });
-    getPanel().querySelector('[data-session-rename]')?.addEventListener('click', event => {
-      event.stopPropagation();
-      beginActiveSessionRename();
-    });
-    getPanel().querySelector('[data-session-menu-trigger]')?.addEventListener('click', event => {
-      event.stopPropagation();
-      toggleSessionMenu();
-    });
-    // Close the dropdown on any click outside it (capture phase, so the
-    // panel's own click-stoppers don't swallow the dismiss — same pattern as
-    // the diagnostics menu) and on Escape.
-    document.addEventListener('click', event => {
-      const menu = getPanel()?.querySelector('[data-session-menu]');
-      if (!menu || menu.hidden) {
-        return;
-      }
-      const trigger = getPanel()?.querySelector('[data-session-menu-trigger]');
-      if (menu.contains(event.target) || trigger?.contains(event.target)) {
-        return;
-      }
-      closeSessionMenu();
-    }, true);
-    document.addEventListener('keydown', event => {
-      if (event.key === 'Escape') {
-        closeSessionMenu();
-      }
-    }, true);
-  }
-
-  // Header session dropdown: lists every saved session where the user works,
-  // switches on click, and offers New session — the embedded list below stays
-  // as the always-visible overview.
-  function toggleSessionMenu() {
-    const menu = getPanel()?.querySelector('[data-session-menu]');
-    if (!menu) {
-      return;
-    }
-    if (menu.hidden) {
-      renderSessionMenu(menu);
-    }
-    menu.hidden = !menu.hidden;
-    getPanel()?.querySelector('[data-session-menu-trigger]')
-      ?.setAttribute('aria-expanded', menu.hidden ? 'false' : 'true');
-  }
-
-  function closeSessionMenu() {
-    const menu = getPanel()?.querySelector('[data-session-menu]');
-    if (!menu || menu.hidden) {
-      return;
-    }
-    menu.hidden = true;
-    getPanel()?.querySelector('[data-session-menu-trigger]')?.setAttribute('aria-expanded', 'false');
-  }
-
-  function renderSessionMenu(menu) {
-    menu.replaceChildren();
-    const state = getState();
-    const sessions = (state?.sessions || [])
-      .filter(isDisplayableSession)
-      .slice()
-      .sort((a, b) => String(b.updatedAt || b.createdAt || '').localeCompare(String(a.updatedAt || a.createdAt || '')));
-    for (const session of sessions) {
-      const row = document.createElement('button');
-      row.type = 'button';
-      row.className = 'codex-session-menu-item';
-      row.dataset.active = session.id === state?.activeSessionId ? 'true' : 'false';
-      row.dataset.running = isSessionRunning(session) ? 'true' : 'false';
-      const title = document.createElement('span');
-      title.className = 'codex-session-menu-item-title';
-      title.textContent = getSessionDisplayTitle(session);
-      title.title = getSessionDisplayTitle(session);
-      const time = document.createElement('time');
-      time.className = 'codex-session-menu-item-time';
-      time.textContent = formatSessionTime(session.updatedAt || session.createdAt);
-      const absoluteTs = session.updatedAt || session.createdAt;
-      if (absoluteTs) {
-        time.title = new Date(absoluteTs).toLocaleString();
-      }
-      row.append(title, time);
-      row.addEventListener('click', event => {
-        event.stopPropagation();
-        closeSessionMenu();
-        if (session.id !== getState()?.activeSessionId) {
-          switchSession(session.id);
-        }
-      });
-      menu.append(row);
-    }
-    const create = document.createElement('button');
-    create.type = 'button';
-    create.className = 'codex-session-menu-new';
-    create.textContent = `+ ${tr('newSession')}`;
-    create.addEventListener('click', event => {
-      event.stopPropagation();
-      closeSessionMenu();
-      startNewSession();
+    const sessionMenuView = window.CodexOverleafSessionMenuView.create({
+      commitSessionRename,
+      deleteSessionWithConfirm,
+      document,
+      formatSessionTime,
+      getActiveSession,
+      getPanel,
+      getSessionDisplayTitle,
+      getState,
+      isDisplayableSession,
+      isSessionRunning,
+      startNewSession,
+      switchSession,
+      tr
     });
-    menu.append(create);
-  }
-
-  // Inline-rename the active session from the header bar (mirrors the per-row
-  // rename: Enter / blur commits, Escape cancels).
-  function beginActiveSessionRename() {
-    const active = getActiveSession(getState());
-    const wrap = getPanel().querySelector('[data-session-label]');
-    const trigger = getPanel().querySelector('[data-session-menu-trigger]');
-    const textNode = getPanel().querySelector('[data-session-label-text]');
-    const input = getPanel().querySelector('[data-session-rename-input]');
-    if (!active || !wrap || !textNode || !input) {
-      return;
-    }
-    closeSessionMenu();
-    let settled = false;
-    wrap.dataset.editing = 'true';
-    // Seed the box from a real title only; an empty/auto session opens blank so
-    // accepting the default does not commit the placeholder as a manual title.
-    const seed = isDisplayableSession(active) ? getSessionDisplayTitle(active) : '';
-    input.value = seed;
-    input.hidden = false;
-    textNode.hidden = true;
-    if (trigger) {
-      trigger.hidden = true;
-    }
-    input.focus();
-    input.select();
-    const cleanup = () => {
-      input.removeEventListener('keydown', onKeydown);
-      input.removeEventListener('blur', onBlur);
-    };
-    const finish = commit => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      input.hidden = true;
-      textNode.hidden = false;
-      if (trigger) {
-        trigger.hidden = false;
-      }
-      delete wrap.dataset.editing;
-      // Treat an unchanged value (incl. a no-op blur) as a cancel so it never
-      // rewrites the title source.
-      if (commit && input.value.trim() !== seed.trim()) {
-        commitSessionRename(active.id, input.value);
-      }
-    };
-    const onKeydown = event => {
-      if (event.key === 'Enter') {
-        event.preventDefault();
-        finish(true);
-      } else if (event.key === 'Escape') {
-        event.preventDefault();
-        finish(false);
-      }
-    };
-    const onBlur = () => finish(true);
-    input.addEventListener('keydown', onKeydown);
-    input.addEventListener('blur', onBlur);
-  }
+    const {
+      applySessionLabel,
+      bindActiveSessionHeader,
+      closeSessionMenu
+    } = sessionMenuView;
 
   async function startNewSession() {
     // Leaving a still-running session is allowed but never silent: the run