@mseep/claudian 2.0.25

package/tests/unit/scripts/rendererSafeUnref.test.ts

@@ -0,0 +1,101 @@
+import * as rendererSafeUnrefHelpers from '../../../scripts/rendererSafeUnref.js';
+
+const {
+  findUnsafeTimerUnrefSites,
+  patchRendererUnsafeUnrefSites,
+} = rendererSafeUnrefHelpers;
+
+describe('rendererSafeUnref helpers', () => {
+  it('patches the known unsafe timer .unref() bundle sites', () => {
+    const input = [
+      'if ($ && !$.killed && $.exitCode === null) setTimeout((Q) => {',
+      '  if (Q.killed || Q.exitCode !== null) return;',
+      '  Q.kill("SIGTERM"), setTimeout((J) => {',
+      '    if (J.exitCode === null) J.kill("SIGKILL");',
+      '  }, 5e3, Q).unref();',
+      '}, wx, $).unref(), $.once("exit", () => D5.delete($));',
+      'await Promise.race([closePromise, new Promise((resolve5) => setTimeout(resolve5, 2e3).unref())]);',
+    ].join('\n');
+
+    const result = patchRendererUnsafeUnrefSites(input);
+
+    expect(result.appliedPatches).toEqual([
+      { name: 'claude-sdk-process-transport-close', count: 1 },
+      { name: 'mcp-sdk-stdio-close-wait', count: 1 },
+    ]);
+    expect(result.contents).toContain('processKillTimer.unref?.();');
+    expect(result.contents).toContain('forceKillTimer.unref?.();');
+    expect(result.contents).toContain('closeTimeout.unref?.();');
+    expect(findUnsafeTimerUnrefSites(result.contents)).toEqual([]);
+  });
+
+  it('patches the current claude-sdk shape with a block-bodied exit handler', () => {
+    const input = [
+      'if ($ && !$.killed && $.exitCode === null) setTimeout((X) => {',
+      '  if (X.killed || X.exitCode !== null) return;',
+      '  X.kill("SIGTERM"), setTimeout((J) => {',
+      '    if (J.exitCode === null) J.kill("SIGKILL");',
+      '  }, 5e3, X).unref();',
+      '}, LM, $).unref(), $.once("exit", () => {',
+      '  if (this.processExitHandler) process.off("exit", this.processExitHandler), this.processExitHandler = void 0;',
+      '});',
+      'else if (this.processExitHandler) process.off("exit", this.processExitHandler), this.processExitHandler = void 0;',
+    ].join('\n');
+
+    const result = patchRendererUnsafeUnrefSites(input);
+
+    expect(result.appliedPatches).toEqual([
+      { name: 'claude-sdk-process-transport-close', count: 1 },
+    ]);
+    expect(result.contents).toContain('processKillTimer.unref?.();');
+    expect(result.contents).toContain('forceKillTimer.unref?.();');
+    expect(result.contents).toContain('this.processExitHandler');
+    expect(findUnsafeTimerUnrefSites(result.contents)).toEqual([]);
+  });
+
+  it('patches the latest claude-sdk async close callback shape', () => {
+    const input = [
+      'if (Q && !Q.killed && Q.exitCode === null) setTimeout((J, Y) => {',
+      '  if (J.exitCode !== null) {',
+      '    Y();',
+      '    return;',
+      '  }',
+      '  if (process.platform === "win32") {',
+      '    setTimeout((X, W) => {',
+      '      if (X.exitCode === null) X.kill("SIGKILL");',
+      '      W();',
+      '    }, 5e3, J, Y).unref();',
+      '    return;',
+      '  }',
+      '  J.kill("SIGTERM"), setTimeout((X) => {',
+      '    if (X.exitCode === null) X.kill("SIGKILL");',
+      '  }, 5e3, J).unref(), Y();',
+      '}, Tx, Q, $).unref(), Q.once("exit", () => VX.delete(Q));',
+    ].join('\n');
+
+    const result = patchRendererUnsafeUnrefSites(input);
+
+    expect(result.appliedPatches).toEqual([
+      { name: 'claude-sdk-process-transport-close-async', count: 1 },
+    ]);
+    expect(result.contents).toContain('processKillTimer.unref?.();');
+    expect(result.contents).toContain('windowsForceKillTimer.unref?.();');
+    expect(result.contents).toContain('forceKillTimer.unref?.();');
+    expect(findUnsafeTimerUnrefSites(result.contents)).toEqual([]);
+  });
+
+  it('reports remaining direct timer .unref() calls but ignores guarded usage', () => {
+    const input = [
+      'const timer = setTimeout(run, 1000);',
+      'timer.unref?.();',
+      'if (timer.unref) timer.unref();',
+      'setTimeout(run, 1000).unref();',
+      'setInterval(run, 1000).unref();',
+    ].join('\n');
+
+    expect(findUnsafeTimerUnrefSites(input)).toEqual([
+      { line: 4, snippet: 'setTimeout(run, 1000).unref()' },
+      { line: 5, snippet: 'setInterval(run, 1000).unref()' },
+    ]);
+  });
+});

package/tests/unit/shared/components/ResumeSessionDropdown.test.ts

@@ -0,0 +1,356 @@
+import { createMockEl } from '@test/helpers/mockElement';
+
+import type { ConversationMeta } from '@/core/types';
+import {
+  ResumeSessionDropdown,
+  type ResumeSessionDropdownCallbacks,
+} from '@/shared/components/ResumeSessionDropdown';
+
+function createMockInput(): any {
+  return {
+    value: '',
+    selectionStart: 0,
+    selectionEnd: 0,
+    focus: jest.fn(),
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+  };
+}
+
+function createMockCallbacks(
+  overrides: Partial<ResumeSessionDropdownCallbacks> = {}
+): ResumeSessionDropdownCallbacks {
+  return {
+    onSelect: jest.fn(),
+    onDismiss: jest.fn(),
+    ...overrides,
+  };
+}
+
+function createConversation(
+  id: string,
+  title: string,
+  opts: Partial<ConversationMeta> = {}
+): ConversationMeta {
+  return {
+    id,
+    providerId: 'claude',
+    title,
+    createdAt: Date.now() - 10000,
+    updatedAt: Date.now() - 5000,
+    messageCount: 3,
+    preview: 'Test preview',
+    ...opts,
+  };
+}
+
+function getRenderedItems(containerEl: any): { title: string; isCurrent: boolean }[] {
+  const dropdownEl = containerEl.children.find(
+    (c: any) => c.hasClass('claudian-resume-dropdown')
+  );
+  if (!dropdownEl) return [];
+  const items = dropdownEl.querySelectorAll('.claudian-resume-item');
+  return items.map((item: any) => {
+    // Check direct children for content div, then find title inside
+    let title = '';
+    for (const child of item.children) {
+      const found = child.querySelector?.('.claudian-resume-item-title');
+      if (found) {
+        title = found.textContent ?? '';
+        break;
+      }
+    }
+
+    return {
+      title,
+      isCurrent: item.hasClass('current'),
+    };
+  });
+}
+
+describe('ResumeSessionDropdown', () => {
+  let containerEl: any;
+  let inputEl: any;
+  let callbacks: ResumeSessionDropdownCallbacks;
+
+  const conversations: ConversationMeta[] = [
+    createConversation('conv-1', 'First Chat', { lastResponseAt: 1000 }),
+    createConversation('conv-2', 'Second Chat', { lastResponseAt: 3000 }),
+    createConversation('conv-3', 'Third Chat', { lastResponseAt: 2000 }),
+  ];
+
+  beforeEach(() => {
+    containerEl = createMockEl();
+    inputEl = createMockInput();
+    callbacks = createMockCallbacks();
+  });
+
+  describe('constructor', () => {
+    it('creates dropdown with visible class', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const dropdownEl = containerEl.children.find(
+        (c: any) => c.hasClass('claudian-resume-dropdown')
+      );
+      expect(dropdownEl).toBeDefined();
+      expect(dropdownEl.hasClass('visible')).toBe(true);
+
+      dropdown.destroy();
+    });
+
+    it('sorts conversations by lastResponseAt descending', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const items = getRenderedItems(containerEl);
+      expect(items[0].title).toBe('Second Chat');  // lastResponseAt: 3000
+      expect(items[1].title).toBe('Third Chat');   // lastResponseAt: 2000
+      expect(items[2].title).toBe('First Chat');   // lastResponseAt: 1000
+
+      dropdown.destroy();
+    });
+
+    it('marks current conversation', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, 'conv-2', callbacks
+      );
+
+      const items = getRenderedItems(containerEl);
+      const currentItem = items.find(i => i.title === 'Second Chat');
+      expect(currentItem?.isCurrent).toBe(true);
+
+      const otherItem = items.find(i => i.title === 'First Chat');
+      expect(otherItem?.isCurrent).toBe(false);
+
+      dropdown.destroy();
+    });
+
+    it('renders empty state when no conversations', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, [], null, callbacks
+      );
+
+      const dropdownEl = containerEl.children.find(
+        (c: any) => c.hasClass('claudian-resume-dropdown')
+      );
+      const emptyEl = dropdownEl?.querySelector('.claudian-resume-empty');
+      expect(emptyEl).toBeDefined();
+      expect(emptyEl?.textContent).toBe('No conversations');
+
+      dropdown.destroy();
+    });
+
+    it('adds input event listener for auto-dismiss', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      expect(inputEl.addEventListener).toHaveBeenCalledWith('input', expect.any(Function));
+
+      dropdown.destroy();
+    });
+  });
+
+  describe('handleKeydown', () => {
+    it('returns false when dropdown is not visible', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      // Hide it first
+      const dropdownEl = containerEl.children.find(
+        (c: any) => c.hasClass('claudian-resume-dropdown')
+      );
+      dropdownEl.removeClass('visible');
+
+      const event = { key: 'ArrowDown', preventDefault: jest.fn() } as any;
+      expect(dropdown.handleKeydown(event)).toBe(false);
+      expect(event.preventDefault).not.toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('navigates down with ArrowDown', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const event = { key: 'ArrowDown', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(true);
+      expect(event.preventDefault).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('navigates up with ArrowUp', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      // Go down first, then up
+      dropdown.handleKeydown({ key: 'ArrowDown', preventDefault: jest.fn() } as any);
+      const event = { key: 'ArrowUp', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(true);
+      expect(event.preventDefault).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('selects with Enter', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const event = { key: 'Enter', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(true);
+      expect(event.preventDefault).toHaveBeenCalled();
+      // First item after sorting is conv-2 (highest lastResponseAt)
+      expect(callbacks.onSelect).toHaveBeenCalledWith('conv-2');
+
+      dropdown.destroy();
+    });
+
+    it('selects with Tab', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const event = { key: 'Tab', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(true);
+      expect(callbacks.onSelect).toHaveBeenCalledWith('conv-2');
+
+      dropdown.destroy();
+    });
+
+    it('dismisses with Escape', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const event = { key: 'Escape', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(true);
+      expect(event.preventDefault).toHaveBeenCalled();
+      expect(callbacks.onDismiss).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('returns false for unhandled keys', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      const event = { key: 'a', preventDefault: jest.fn() } as any;
+      const result = dropdown.handleKeydown(event);
+
+      expect(result).toBe(false);
+      expect(event.preventDefault).not.toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('dismisses when selecting current conversation', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, 'conv-2', callbacks
+      );
+
+      // conv-2 is first after sorting (highest lastResponseAt), so Enter selects it
+      const event = { key: 'Enter', preventDefault: jest.fn() } as any;
+      dropdown.handleKeydown(event);
+
+      // Should dismiss, not call onSelect
+      expect(callbacks.onSelect).not.toHaveBeenCalled();
+      expect(callbacks.onDismiss).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+  });
+
+  describe('isVisible', () => {
+    it('returns true after construction', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      expect(dropdown.isVisible()).toBe(true);
+
+      dropdown.destroy();
+    });
+
+    it('returns false after Escape', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      dropdown.handleKeydown({ key: 'Escape', preventDefault: jest.fn() } as any);
+
+      expect(dropdown.isVisible()).toBe(false);
+
+      dropdown.destroy();
+    });
+  });
+
+  describe('destroy', () => {
+    it('removes input event listener', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, null, callbacks
+      );
+
+      dropdown.destroy();
+
+      expect(inputEl.removeEventListener).toHaveBeenCalledWith('input', expect.any(Function));
+    });
+  });
+
+  describe('click selection', () => {
+    it('calls onSelect when clicking a non-current item', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, 'conv-1', callbacks
+      );
+
+      const dropdownEl = containerEl.children.find(
+        (c: any) => c.hasClass('claudian-resume-dropdown')
+      );
+      const items = dropdownEl.querySelectorAll('.claudian-resume-item');
+      // Find a non-current item (conv-2 is first, conv-1 is current)
+      const nonCurrentItem = items.find((i: any) => !i.hasClass('current'));
+      nonCurrentItem?.dispatchEvent('click');
+
+      expect(callbacks.onSelect).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+
+    it('dismisses when clicking current item', () => {
+      const dropdown = new ResumeSessionDropdown(
+        containerEl, inputEl, conversations, 'conv-2', callbacks
+      );
+
+      const dropdownEl = containerEl.children.find(
+        (c: any) => c.hasClass('claudian-resume-dropdown')
+      );
+      const items = dropdownEl.querySelectorAll('.claudian-resume-item');
+      // conv-2 is first after sorting and is current
+      const currentItem = items.find((i: any) => i.hasClass('current'));
+      currentItem?.dispatchEvent('click');
+
+      expect(callbacks.onSelect).not.toHaveBeenCalled();
+      expect(callbacks.onDismiss).toHaveBeenCalled();
+
+      dropdown.destroy();
+    });
+  });
+});