@mseep/claudian 2.0.25

package/tests/helpers/mockElement.ts

@@ -0,0 +1,403 @@
+export interface MockElement {
+  tagName: string;
+  children: MockElement[];
+  style: Record<string, string>;
+  dataset: Record<string, string>;
+  scrollTop: number;
+  scrollHeight: number;
+  innerHTML: string;
+  textContent: string;
+  className: string;
+  classList: {
+    add: (cls: string) => void;
+    remove: (cls: string) => void;
+    contains: (cls: string) => boolean;
+    toggle: (cls: string, force?: boolean) => boolean;
+  };
+  addClass: (cls: string) => MockElement;
+  removeClass: (cls: string) => MockElement;
+  hasClass: (cls: string) => boolean;
+  getClasses: () => string[];
+  createDiv: (opts?: { cls?: string; text?: string }) => MockElement;
+  createSpan: (opts?: { cls?: string; text?: string }) => MockElement;
+  createEl: (tag: string, opts?: { cls?: string; text?: string; attr?: Record<string, string> }) => MockElement;
+  appendChild: (child: any) => any;
+  insertBefore: (el: MockElement, ref: MockElement | null) => void;
+  firstChild: MockElement | null;
+  remove: () => void;
+  empty: () => void;
+  contains: (node: any) => boolean;
+  scrollIntoView: () => void;
+  setAttribute: (name: string, value: string) => void;
+  getAttribute: (name: string) => string | undefined | null;
+  removeAttribute: (name: string) => void;
+  addEventListener: (event: string, handler: (...args: any[]) => void) => void;
+  removeEventListener: (event: string, handler: (...args: any[]) => void) => void;
+  dispatchEvent: (eventOrType: string | { type: string; [key: string]: any }, extraArg?: any) => void;
+  click: () => void;
+  getEventListenerCount: (event: string) => number;
+  querySelector: (selector: string) => MockElement | null;
+  querySelectorAll: (selector: string) => MockElement[];
+  getBoundingClientRect: () => { top: number; left: number; width: number; height: number; right: number; bottom: number; x: number; y: number; toJSON: () => void };
+  setText: (text: string) => void;
+  appendText: (text: string) => void;
+  setCssProps: (props: Record<string, string>) => void;
+  ownerDocument: {
+    defaultView: {
+      requestAnimationFrame: (callback: FrameRequestCallback) => number;
+      cancelAnimationFrame: (handle: number) => void;
+      setTimeout: (callback: () => void, timeout: number) => number;
+      clearTimeout: (handle: number) => void;
+      setInterval: (callback: () => void, timeout: number) => number;
+      clearInterval: (handle: number) => void;
+    };
+    activeElement?: any;
+    body?: any;
+    addEventListener?: (event: string, handler: (...args: any[]) => void) => void;
+    removeEventListener?: (event: string, handler: (...args: any[]) => void) => void;
+    createElement: (tagName: string) => MockElement;
+    createElementNS: (namespace: string, tagName: string) => MockElement;
+    getSelection?: () => Selection | null;
+  };
+  _classes: Set<string>;
+  _classList: Set<string>;
+  _attributes: Map<string, string>;
+  _eventListeners: Map<string, Array<(...args: any[]) => void>>;
+  _children: MockElement[];
+  [key: string]: any;
+}
+
+const CLASS_DISPLAY: Record<string, string> = {
+  'claudian-browser-selection-indicator': 'block',
+  'claudian-canvas-indicator': 'block',
+  'claudian-context-meter': 'flex',
+  'claudian-file-indicator': 'none',
+  'claudian-image-preview': 'none',
+  'claudian-mcp-selector': 'flex',
+  'claudian-mode-selector': 'flex',
+  'claudian-permission-toggle': 'flex',
+  'claudian-selection-indicator': 'block',
+  'claudian-service-tier-toggle': 'flex',
+  'claudian-status-panel-bash': 'block',
+  'claudian-status-panel-bash-content': 'block',
+  'claudian-status-panel-bash-entry-content': 'block',
+  'claudian-status-panel-content': 'block',
+  'claudian-status-panel-todos': 'block',
+  'claudian-tab-content': 'flex',
+  'claudian-thinking-budget': 'flex',
+  'claudian-thinking-effort': 'flex',
+};
+
+const DISPLAY_CLASSES = new Set([
+  'claudian-hidden',
+  'claudian-visible-block',
+  'claudian-visible-flex',
+  ...Object.keys(CLASS_DISPLAY),
+]);
+
+export function createMockEl(tag = 'div'): any {
+  const children: MockElement[] = [];
+  const classes = new Set<string>();
+  const attributes = new Map<string, string>();
+  const eventListeners = new Map<string, Array<(...args: any[]) => void>>();
+  const dataset: Record<string, string> = {};
+  const style: Record<string, string> = {};
+  let textContent = '';
+
+  const resolveDisplay = (): string | null => {
+    if (classes.has('claudian-hidden')) return 'none';
+    if (classes.has('claudian-visible-flex')) return 'flex';
+    if (classes.has('claudian-visible-block')) return 'block';
+
+    for (const [cls, display] of Object.entries(CLASS_DISPLAY)) {
+      if (classes.has(cls)) return display;
+    }
+
+    return null;
+  };
+
+  const syncDisplay = () => {
+    const display = resolveDisplay();
+    if (display === null) {
+      style.display = '';
+      return;
+    }
+    style.display = display;
+  };
+
+  const updateClass = (cls: string, enabled: boolean) => {
+    if (enabled) {
+      classes.add(cls);
+    } else {
+      classes.delete(cls);
+    }
+    if (DISPLAY_CLASSES.has(cls)) {
+      syncDisplay();
+    }
+  };
+
+  const defaultView = {
+    requestAnimationFrame: (callback: FrameRequestCallback): number => {
+      const requestFrame =
+        (globalThis as { window?: Window }).window?.requestAnimationFrame
+        ?? (globalThis as { requestAnimationFrame?: typeof requestAnimationFrame }).requestAnimationFrame;
+      if (typeof requestFrame === 'function') {
+        return requestFrame(callback);
+      }
+      return globalThis.setTimeout(() => callback(performance.now()), 16) as unknown as number;
+    },
+    cancelAnimationFrame: (handle: number): void => {
+      const cancelFrame =
+        (globalThis as { window?: Window }).window?.cancelAnimationFrame
+        ?? (globalThis as { cancelAnimationFrame?: typeof cancelAnimationFrame }).cancelAnimationFrame;
+      if (typeof cancelFrame === 'function') {
+        cancelFrame(handle);
+        return;
+      }
+      globalThis.clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+    },
+    setTimeout: (callback: () => void, timeout: number): number =>
+      globalThis.setTimeout(callback, timeout) as unknown as number,
+    clearTimeout: (handle: number): void => {
+      globalThis.clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+    },
+    setInterval: (callback: () => void, timeout: number): number =>
+      globalThis.setInterval(callback, timeout) as unknown as number,
+    clearInterval: (handle: number): void => {
+      globalThis.clearInterval(handle as unknown as ReturnType<typeof setInterval>);
+    },
+  };
+
+  const currentDocument = (): any => (globalThis as any).document;
+  const ownerDocument = {
+    defaultView,
+    get activeElement() {
+      return currentDocument()?.activeElement ?? null;
+    },
+    get body() {
+      return currentDocument()?.body;
+    },
+    addEventListener(event: string, handler: (...args: any[]) => void) {
+      currentDocument()?.addEventListener?.(event, handler);
+    },
+    removeEventListener(event: string, handler: (...args: any[]) => void) {
+      currentDocument()?.removeEventListener?.(event, handler);
+    },
+    createElement: (tagName: string) => currentDocument()?.createElement?.(tagName) ?? createMockEl(tagName),
+    createElementNS: (namespace: string, tagName: string) =>
+      currentDocument()?.createElementNS?.(namespace, tagName) ?? createMockEl(tagName),
+    getSelection: () => currentDocument()?.getSelection?.() ?? null,
+  };
+
+  const element: MockElement = {
+    tagName: tag.toUpperCase(),
+    children,
+    style,
+    dataset,
+    scrollTop: 0,
+    scrollHeight: 0,
+    innerHTML: '',
+
+    get textContent() {
+      return textContent;
+    },
+    set textContent(value: string) {
+      textContent = value;
+    },
+
+    get className() {
+      return Array.from(classes).join(' ');
+    },
+    set className(value: string) {
+      classes.clear();
+      if (value) {
+        value.split(' ').filter(Boolean).forEach(c => classes.add(c));
+      }
+      syncDisplay();
+    },
+
+    classList: {
+      add: (cls: string) => updateClass(cls, true),
+      remove: (cls: string) => updateClass(cls, false),
+      contains: (cls: string) => classes.has(cls),
+      toggle: (cls: string, force?: boolean) => {
+        if (force === undefined) {
+          if (classes.has(cls)) {
+            updateClass(cls, false);
+            return false;
+          }
+          updateClass(cls, true);
+          return true;
+        }
+        updateClass(cls, force);
+        return force;
+      },
+    },
+
+    addClass(cls: string) {
+      cls.split(/\s+/).filter(Boolean).forEach(c => updateClass(c, true));
+      return element;
+    },
+    removeClass(cls: string) {
+      cls.split(/\s+/).filter(Boolean).forEach(c => updateClass(c, false));
+      return element;
+    },
+    hasClass: (cls: string) => classes.has(cls),
+    getClasses: () => Array.from(classes),
+
+    createDiv(opts?: { cls?: string; text?: string }) {
+      const child = createMockEl('div');
+      if (opts?.cls) child.addClass(opts.cls);
+      if (opts?.text) child.textContent = opts.text;
+      children.push(child);
+      return child;
+    },
+    createSpan(opts?: { cls?: string; text?: string }) {
+      const child = createMockEl('span');
+      if (opts?.cls) child.addClass(opts.cls);
+      if (opts?.text) child.textContent = opts.text;
+      children.push(child);
+      return child;
+    },
+    createEl(tagName: string, opts?: { cls?: string; text?: string; attr?: Record<string, string> }) {
+      const child = createMockEl(tagName);
+      if (opts?.cls) child.addClass(opts.cls);
+      if (opts?.text) child.textContent = opts.text;
+      if (opts?.attr) {
+        for (const [name, value] of Object.entries(opts.attr)) {
+          child.setAttribute(name, value);
+        }
+      }
+      children.push(child);
+      return child;
+    },
+
+    appendChild(child: any) { children.push(child); return child; },
+    insertBefore(el: MockElement, _ref: MockElement | null) { children.unshift(el); },
+    get firstChild() { return children[0] || null; },
+    remove() {},
+    empty() {
+      children.length = 0;
+      element.innerHTML = '';
+      textContent = '';
+    },
+    contains(node: any) {
+      if (node === element) return true;
+      return children.some(child => (child as any).contains?.(node));
+    },
+    scrollIntoView() {},
+    focus() {
+      const handlers = eventListeners.get('focus') || [];
+      handlers.forEach(h => h({ type: 'focus', target: element }));
+    },
+    blur() {
+      const handlers = eventListeners.get('blur') || [];
+      handlers.forEach(h => h({ type: 'blur', target: element }));
+    },
+    select() {},
+
+    setAttribute(name: string, value: string) {
+      if (name === 'class') {
+        element.className = value;
+      } else {
+        attributes.set(name, value);
+      }
+      if (name.startsWith('data-')) {
+        dataset[name.slice(5).replace(/-([a-z])/g, (_, char: string) => char.toUpperCase())] = value;
+      }
+    },
+    getAttribute(name: string) {
+      if (name === 'class') return element.className;
+      return attributes.get(name) ?? null;
+    },
+    removeAttribute(name: string) {
+      if (name === 'class') {
+        element.className = '';
+      } else {
+        attributes.delete(name);
+      }
+      if (name.startsWith('data-')) {
+        delete dataset[name.slice(5).replace(/-([a-z])/g, (_, char: string) => char.toUpperCase())];
+      }
+    },
+
+    addEventListener(event: string, handler: (...args: any[]) => void) {
+      if (!eventListeners.has(event)) eventListeners.set(event, []);
+      eventListeners.get(event)!.push(handler);
+    },
+    removeEventListener(event: string, handler: (...args: any[]) => void) {
+      const handlers = eventListeners.get(event);
+      if (handlers) {
+        const idx = handlers.indexOf(handler);
+        if (idx !== -1) handlers.splice(idx, 1);
+      }
+    },
+    dispatchEvent(eventOrType: string | { type: string; [key: string]: any }, extraArg?: any) {
+      if (typeof eventOrType === 'string') {
+        const handlers = eventListeners.get(eventOrType) || [];
+        handlers.forEach(h => h(extraArg));
+      } else {
+        const handlers = eventListeners.get(eventOrType.type) || [];
+        handlers.forEach(h => h(eventOrType));
+      }
+    },
+    click() {
+      const handlers = eventListeners.get('click') || [];
+      handlers.forEach(h => h({ type: 'click', target: element, stopPropagation: () => {} }));
+    },
+    getEventListenerCount(event: string) {
+      return eventListeners.get(event)?.length ?? 0;
+    },
+
+    querySelector(selector: string) {
+      const cls = selector.replace('.', '');
+      const find = (el: any): MockElement | null => {
+        if (el.hasClass?.(cls)) return el;
+        for (const child of el.children || []) {
+          const found = find(child);
+          if (found) return found;
+        }
+        return null;
+      };
+      return find(element);
+    },
+    querySelectorAll(selector: string) {
+      const cls = selector.replace('.', '');
+      const results: MockElement[] = [];
+      const collect = (el: any) => {
+        if (el.hasClass?.(cls)) results.push(el);
+        for (const child of el.children || []) collect(child);
+      };
+      for (const child of children) collect(child);
+      return results;
+    },
+
+    getBoundingClientRect() {
+      return { top: 0, left: 0, width: 0, height: 0, right: 0, bottom: 0, x: 0, y: 0, toJSON() {} };
+    },
+
+    setText(text: string) { textContent = text; },
+    appendText(text: string) { textContent += text; },
+    setCssProps(props: Record<string, string>) {
+      for (const [name, value] of Object.entries(props)) {
+        style[name] = value;
+      }
+    },
+    setAttr(name: string, value: string) { element.setAttribute(name, value); },
+    toggleClass(cls: string, force: boolean) {
+      updateClass(cls, force);
+    },
+    value: '',
+    closest() { return { clientHeight: 600 }; },
+    getEventListeners() { return eventListeners; },
+    ownerDocument,
+
+    _classes: classes,
+    _classList: classes,
+    _attributes: attributes,
+    _eventListeners: eventListeners,
+    _children: children,
+  };
+
+  return element;
+}

package/tests/helpers/sdkMessages.ts

@@ -0,0 +1,291 @@
+import type {
+  SDKAssistantMessage,
+  SDKAuthStatusMessage,
+  SDKCompactBoundaryMessage,
+  SDKMessage,
+  SDKPartialAssistantMessage,
+  SDKResultError,
+  SDKResultSuccess,
+  SDKStatusMessage,
+  SDKSystemMessage,
+  SDKToolProgressMessage,
+  SDKUserMessage,
+} from '@anthropic-ai/claude-agent-sdk';
+
+const TEST_UUID = '00000000-0000-4000-8000-000000000001';
+const TEST_SESSION_ID = 'test-session';
+
+const DEFAULT_RESULT_USAGE = ({
+  input_tokens: 0,
+  output_tokens: 0,
+  cache_creation_input_tokens: 0,
+  cache_read_input_tokens: 0,
+} as unknown) as SDKResultSuccess['usage'];
+
+const DEFAULT_MODEL_USAGE: SDKResultSuccess['modelUsage'] = {
+  'claude-sonnet-test': {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    webSearchRequests: 0,
+    costUSD: 0,
+    contextWindow: 200000,
+    maxOutputTokens: 8192,
+  },
+};
+
+export type SystemInitMessageInput = {
+  type: 'system';
+  subtype: 'init';
+} & Partial<Omit<SDKSystemMessage, 'type' | 'subtype'>>;
+
+export type SystemStatusMessageInput = {
+  type: 'system';
+  subtype: 'status';
+} & Partial<Omit<SDKStatusMessage, 'type' | 'subtype'>>;
+
+export type CompactBoundaryMessageInput = {
+  type: 'system';
+  subtype: 'compact_boundary';
+} & Partial<Omit<SDKCompactBoundaryMessage, 'type' | 'subtype'>>;
+
+export type AssistantMessageInput = {
+  type: 'assistant';
+} & Record<string, unknown>;
+
+export type UserMessageInput = {
+  type: 'user';
+  _blocked?: boolean;
+  _blockReason?: string;
+} & Record<string, unknown>;
+
+export type StreamEventMessageInput = {
+  type: 'stream_event';
+} & Record<string, unknown>;
+
+export type ResultSuccessMessageInput = {
+  type: 'result';
+  subtype?: 'success';
+} & Record<string, unknown>;
+
+export type ResultErrorMessageInput = {
+  type: 'result';
+  subtype: SDKResultError['subtype'];
+} & Record<string, unknown>;
+
+export type ToolProgressMessageInput = {
+  type: 'tool_progress';
+} & Partial<Omit<SDKToolProgressMessage, 'type'>>;
+
+export type AuthStatusMessageInput = {
+  type: 'auth_status';
+} & Partial<Omit<SDKAuthStatusMessage, 'type'>>;
+
+export type SDKTestMessageInput =
+  | SystemInitMessageInput
+  | SystemStatusMessageInput
+  | CompactBoundaryMessageInput
+  | AssistantMessageInput
+  | UserMessageInput
+  | StreamEventMessageInput
+  | ResultSuccessMessageInput
+  | ResultErrorMessageInput
+  | ToolProgressMessageInput
+  | AuthStatusMessageInput;
+
+export function buildSystemInitMessage(overrides: Partial<Omit<SDKSystemMessage, 'type' | 'subtype'>> = {}): SDKSystemMessage {
+  return {
+    type: 'system',
+    subtype: 'init',
+    apiKeySource: 'user',
+    claude_code_version: 'test-version',
+    cwd: '/test/cwd',
+    tools: [],
+    mcp_servers: [],
+    model: 'claude-sonnet-4-5',
+    permissionMode: 'default',
+    slash_commands: [],
+    output_style: 'default',
+    skills: [],
+    plugins: [],
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...overrides,
+  };
+}
+
+export function buildSystemStatusMessage(overrides: Partial<Omit<SDKStatusMessage, 'type' | 'subtype'>> = {}): SDKStatusMessage {
+  return {
+    type: 'system',
+    subtype: 'status',
+    status: null,
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...overrides,
+  };
+}
+
+export function buildCompactBoundaryMessage(
+  overrides: Partial<Omit<SDKCompactBoundaryMessage, 'type' | 'subtype'>> = {}
+): SDKCompactBoundaryMessage {
+  return {
+    type: 'system',
+    subtype: 'compact_boundary',
+    compact_metadata: {
+      trigger: 'manual',
+      pre_tokens: 0,
+    },
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...overrides,
+  };
+}
+
+export function buildAssistantMessage(overrides: AssistantMessageInput): SDKAssistantMessage {
+  return {
+    type: 'assistant',
+    message: ({ content: [] } as unknown) as SDKAssistantMessage['message'],
+    parent_tool_use_id: null,
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...(overrides as Partial<Omit<SDKAssistantMessage, 'type'>>),
+  };
+}
+
+export function buildUserMessage(overrides: UserMessageInput): SDKUserMessage {
+  return {
+    type: 'user',
+    message: ({ content: [] } as unknown) as SDKUserMessage['message'],
+    parent_tool_use_id: null,
+    session_id: TEST_SESSION_ID,
+    ...(overrides as Partial<Omit<SDKUserMessage, 'type'>>),
+  };
+}
+
+export function buildStreamEventMessage(
+  overrides: StreamEventMessageInput
+): SDKPartialAssistantMessage {
+  return {
+    type: 'stream_event',
+    event: ({
+      type: 'content_block_delta',
+      delta: { type: 'text_delta', text: '' },
+    } as unknown) as SDKPartialAssistantMessage['event'],
+    parent_tool_use_id: null,
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...(overrides as Partial<Omit<SDKPartialAssistantMessage, 'type'>>),
+  };
+}
+
+export function buildResultSuccessMessage(
+  overrides: Omit<ResultSuccessMessageInput, 'type' | 'subtype'> = {}
+): SDKResultSuccess {
+  return {
+    type: 'result',
+    subtype: 'success',
+    duration_ms: 0,
+    duration_api_ms: 0,
+    is_error: false,
+    num_turns: 1,
+    result: 'completed',
+    stop_reason: null,
+    total_cost_usd: 0,
+    usage: DEFAULT_RESULT_USAGE,
+    modelUsage: DEFAULT_MODEL_USAGE,
+    permission_denials: [],
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...(overrides as Partial<Omit<SDKResultSuccess, 'type' | 'subtype'>>),
+  };
+}
+
+export function buildResultErrorMessage(
+  overrides: Omit<ResultErrorMessageInput, 'type'> & Pick<ResultErrorMessageInput, 'subtype'>
+): SDKResultError {
+  const { subtype, ...rest } = overrides;
+
+  return {
+    type: 'result',
+    subtype,
+    duration_ms: 0,
+    duration_api_ms: 0,
+    is_error: true,
+    num_turns: 1,
+    stop_reason: null,
+    total_cost_usd: 0,
+    usage: DEFAULT_RESULT_USAGE,
+    modelUsage: DEFAULT_MODEL_USAGE,
+    permission_denials: [],
+    errors: ['SDK reported an execution error'],
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...(rest as Partial<Omit<SDKResultError, 'type' | 'subtype'>>),
+  };
+}
+
+export function buildToolProgressMessage(
+  overrides: Partial<Omit<SDKToolProgressMessage, 'type'>> = {}
+): SDKToolProgressMessage {
+  return {
+    type: 'tool_progress',
+    tool_use_id: 'tool-1',
+    tool_name: 'Bash',
+    parent_tool_use_id: null,
+    elapsed_time_seconds: 0,
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...overrides,
+  };
+}
+
+export function buildAuthStatusMessage(
+  overrides: Partial<Omit<SDKAuthStatusMessage, 'type'>> = {}
+): SDKAuthStatusMessage {
+  return {
+    type: 'auth_status',
+    isAuthenticating: false,
+    output: [],
+    uuid: TEST_UUID,
+    session_id: TEST_SESSION_ID,
+    ...overrides,
+  };
+}
+
+function isResultErrorInput(input: ResultSuccessMessageInput | ResultErrorMessageInput): input is ResultErrorMessageInput {
+  return input.subtype !== undefined && input.subtype !== 'success';
+}
+
+export function buildSDKMessage(input: SDKTestMessageInput): SDKMessage {
+  switch (input.type) {
+    case 'system':
+      if (input.subtype === 'init') return buildSystemInitMessage(input);
+      if (input.subtype === 'status') return buildSystemStatusMessage(input);
+      return buildCompactBoundaryMessage(input);
+    case 'assistant':
+      return buildAssistantMessage(input);
+    case 'user': {
+      const message = buildUserMessage(input);
+      if (input._blocked === true) {
+        return {
+          ...message,
+          _blocked: true,
+          _blockReason: input._blockReason ?? 'Blocked by hook',
+        } as SDKMessage;
+      }
+      return message;
+    }
+    case 'stream_event':
+      return buildStreamEventMessage(input);
+    case 'result':
+      if (isResultErrorInput(input)) {
+        return buildResultErrorMessage(input);
+      }
+      return buildResultSuccessMessage(input);
+    case 'tool_progress':
+      return buildToolProgressMessage(input);
+    case 'auth_status':
+      return buildAuthStatusMessage(input);
+  }
+}