jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/tests/e2e/freeze-notebook-tabs-repro.spec.js

@@ -0,0 +1,295 @@
+const path = require('path');
+const { test, expect } = require('@playwright/test');
+
+const DOCS = [
+  { path: 'tests/e2e/fixtures/notebooks/tab1.py', name: 'tab1.py', kind: 'py' },
+  { path: 'tests/e2e/fixtures/notebooks/tab2.py', name: 'tab2.py', kind: 'py' },
+  { path: 'tests/e2e/fixtures/notebooks/tab3.py', name: 'tab3.py', kind: 'py' },
+  { path: 'tests/e2e/fixtures/notebooks/tab4.py', name: 'tab4.py', kind: 'py' }
+];
+
+const STRESS_PROMPT = '양자역학을 시뮬레이팅하는 코드를 작성해줘';
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function buildInitialDocumentUrl(baseLabUrl, documentPath) {
+  const parsed = new URL(baseLabUrl);
+  const basePath = parsed.pathname.replace(/\/$/, '');
+  parsed.pathname = `${basePath}/tree/${documentPath}`;
+  parsed.searchParams.set('reset', '1');
+  return parsed.toString();
+}
+
+async function dismissBlockingDialogs(page) {
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const dialog = page.locator('dialog.jp-Dialog, [role="dialog"].jp-Dialog, [role="dialog"]').first();
+    if (!(await dialog.count()) || !(await dialog.isVisible())) {
+      return;
+    }
+
+    const clickedNoKernel = await page.evaluate(() => {
+      const buttons = Array.from(
+        document.querySelectorAll('dialog.jp-Dialog button, [role="dialog"] button')
+      );
+      const target = buttons.find(button => /No Kernel/i.test(button.textContent || ''));
+      if (!target) {
+        return false;
+      }
+      target.click();
+      return true;
+    });
+    if (clickedNoKernel) {
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    const clickedSelect = await page.evaluate(() => {
+      const buttons = Array.from(
+        document.querySelectorAll('dialog.jp-Dialog button, [role="dialog"] button')
+      );
+      const target = buttons.find(button => /^Select$/i.test((button.textContent || '').trim()));
+      if (!target) {
+        return false;
+      }
+      target.click();
+      return true;
+    });
+    if (clickedSelect) {
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    const clickedCancel = await page.evaluate(() => {
+      const buttons = Array.from(
+        document.querySelectorAll('dialog.jp-Dialog button, [role="dialog"] button')
+      );
+      const target = buttons.find(button => /^Cancel$/i.test((button.textContent || '').trim()));
+      if (!target) {
+        return false;
+      }
+      target.click();
+      return true;
+    });
+    if (clickedCancel) {
+      await page.waitForTimeout(120);
+      continue;
+    }
+
+    await page.keyboard.press('Escape');
+    await page.waitForTimeout(120);
+  }
+}
+
+async function ensureFileBrowserVisible(page) {
+  await dismissBlockingDialogs(page);
+  const fileBrowserTab = page.getByRole('tab', { name: /File Browser/i }).first();
+  if (await fileBrowserTab.count()) {
+    const isActiveBefore = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveBefore) {
+      await fileBrowserTab.click();
+    }
+    const isActiveAfter = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveAfter) {
+      await fileBrowserTab.click();
+    }
+  }
+  await expect(page.locator('.jp-BreadCrumbs-home')).toBeVisible({ timeout: 10000 });
+}
+
+async function openDocumentFromFileBrowser(page, documentName) {
+  await ensureFileBrowserVisible(page);
+  let item = page
+    .getByRole('listitem', { name: new RegExp(`\\b${escapeRegExp(documentName)}\\b`, 'i') })
+    .first();
+  if (!(await item.count())) {
+    item = page.locator('.jp-DirListing-item', { hasText: documentName }).first();
+  }
+  if (!(await item.count())) {
+    item = page.locator('.jp-FileBrowser').getByText(documentName, { exact: true }).first();
+  }
+  await expect(item).toBeVisible({ timeout: 20000 });
+  await dismissBlockingDialogs(page);
+  await item.dblclick();
+  await dismissBlockingDialogs(page);
+}
+
+async function activateDocumentTab(page, documentName) {
+  await dismissBlockingDialogs(page);
+  const exactTab = page.getByRole('tab', { name: new RegExp(`^${escapeRegExp(documentName)}$`) }).first();
+  await expect(exactTab).toBeVisible({ timeout: 20000 });
+  await exactTab.click();
+  await expect(page.locator('.jp-CodexChat-notebook')).toHaveText(documentName, { timeout: 20000 });
+}
+
+async function ensureCodexPanel(page) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexPanel .jp-CodexComposer textarea');
+  if ((await composer.count()) > 0 && (await composer.first().isVisible())) {
+    return;
+  }
+
+  const codexSideTab = page
+    .locator('.jp-SideBar.jp-mod-right .lm-TabBar-tab[title="Codex"], .jp-SideBar.jp-mod-right .lm-TabBar-tab')
+    .filter({ hasText: 'Codex' })
+    .first();
+  await expect(codexSideTab).toBeVisible({ timeout: 20000 });
+  await codexSideTab.click();
+
+  await expect(composer.first()).toBeVisible({ timeout: 20000 });
+}
+
+async function sendMessage(page, text) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexComposer textarea');
+  const sendBtn = page.locator('.jp-CodexSendBtn:visible');
+
+  await expect(composer).toBeVisible({ timeout: 20000 });
+  await composer.fill(text);
+  const isEnabled = await sendBtn.isEnabled();
+  if (!isEnabled) {
+    return false;
+  }
+  await sendBtn.click();
+  await expect(page.locator('.jp-CodexSendBtn.is-stop')).toBeVisible({ timeout: 15000 });
+  return true;
+}
+
+async function sendMessageFromCurrentTab(page, text, options = {}) {
+  const sendAllowed = options.sendAllowed ?? true;
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexComposer textarea');
+  const sendBtn = page.locator('.jp-CodexSendBtn:visible');
+
+  await expect(composer).toBeVisible({ timeout: 20000 });
+  await composer.fill(text);
+
+  const isEnabled = await sendBtn.isEnabled();
+  if (!sendAllowed) {
+    expect(isEnabled).toBe(false);
+    return false;
+  }
+  if (!isEnabled) {
+    return false;
+  }
+
+  await sendBtn.click();
+  await expect(page.locator('.jp-CodexSendBtn.is-stop')).toBeVisible({ timeout: 15000 });
+  return true;
+}
+
+async function keepLastPyTabInteractive(page, durationMs = 15000) {
+  const editor = page
+    .locator('.jp-FileEditor .cm-content:visible, .jp-CodeMirrorEditor .cm-content:visible')
+    .first();
+  await expect(editor).toBeVisible({ timeout: 20000 });
+
+  const probe = `PW_UI_RESPONSIVE_PROBE_MARKER_${Date.now()}`;
+  await editor.click({ timeout: 5000 });
+  await page.keyboard.type(`\n# ${probe}`);
+  await expect(editor).toContainText(probe, { timeout: 5000 });
+
+  const deadline = Date.now() + durationMs;
+  let round = 0;
+  while (Date.now() < deadline) {
+    try {
+      await editor.click({ timeout: 1000 });
+      const marker = `PW_UI_RESPONSIVE_ROUND_${round}`;
+      await page.keyboard.type(`\n# ${marker}`);
+      await expect(editor).toContainText(marker, { timeout: 1000 });
+      await page.mouse.wheel(0, 420);
+      await page.mouse.wheel(0, -420);
+    } catch (err) {
+      const dismissed = await page.evaluate(() => {
+        const buttons = Array.from(document.querySelectorAll('dialog.jp-Dialog button, [role="dialog"] button'));
+        const target = buttons.find(button =>
+          /^(No Kernel|Cancel|Reload|Select)$/i.test((button.textContent || '').trim())
+        );
+        if (!target) {
+          return false;
+        }
+        target.click();
+        return true;
+      });
+      if (!dismissed) {
+        throw err;
+      }
+    }
+    round += 1;
+    await page.waitForTimeout(80);
+  }
+}
+
+test('4 notebook-tab rapid sends with immediate tab switching keep final .py tab interactive', async ({ page, baseURL }) => {
+  const codexCommandPath =
+    process.env.PLAYWRIGHT_CODEX_COMMAND || path.resolve(__dirname, 'mock-codex-cli-flood.py');
+  const targetUrl = baseURL || process.env.JUPYTERLAB_URL || 'http://127.0.0.1:8888/lab';
+  const interactiveMsRaw = Number(process.env.PLAYWRIGHT_INTERACTIVE_MS || '60000');
+  const interactiveMs = Number.isFinite(interactiveMsRaw) ? Math.max(1000, Math.floor(interactiveMsRaw)) : 18000;
+  const initialDocumentUrl = buildInitialDocumentUrl(targetUrl, DOCS[0].path);
+  const pageErrors = [];
+  const codexConsoleErrors = [];
+
+  page.on('pageerror', err => {
+    pageErrors.push(String(err?.message || err));
+  });
+  page.on('console', msg => {
+    if (msg.type() !== 'error') {
+      return;
+    }
+    const text = msg.text();
+    if (text.includes('[Codex] onSocketMessage failed') || text.includes('Internal UI error')) {
+      codexConsoleErrors.push(text);
+    }
+  });
+
+  await page.addInitScript(commandPath => {
+    window.localStorage.setItem('jupyterlab-codex:command-path', commandPath);
+    window.localStorage.setItem('jupyterlab-codex:model', 'gpt-5.3-codex');
+    window.localStorage.setItem('jupyterlab-codex:reasoning-effort', 'high');
+  }, codexCommandPath);
+
+  await page.goto(initialDocumentUrl, { waitUntil: 'domcontentloaded' });
+  await page.waitForSelector('main[aria-label="Main Content"], .jp-LabShell, .lm-DockPanel', {
+    timeout: 30000
+  });
+  await dismissBlockingDialogs(page);
+  await ensureCodexPanel(page);
+
+  for (const document of DOCS.slice(1)) {
+    await openDocumentFromFileBrowser(page, document.name);
+  }
+
+  for (const document of DOCS.slice(0, 1)) {
+    await activateDocumentTab(page, document.name);
+    const sent = await sendMessage(page, STRESS_PROMPT);
+    expect(sent).toBe(true);
+  }
+
+  for (let round = 0; round < 5; round += 1) {
+    for (const document of DOCS.slice(1)) {
+      await activateDocumentTab(page, document.name);
+      const sent = await sendMessageFromCurrentTab(page, STRESS_PROMPT, { sendAllowed: false });
+      expect(sent).toBe(false);
+  await expect(page.locator('.jp-CodexSendBtn:visible')).toBeDisabled({ timeout: 5000 });
+    }
+  }
+
+  const lastDoc = DOCS[DOCS.length - 1];
+  await activateDocumentTab(page, lastDoc.name);
+  await keepLastPyTabInteractive(page, interactiveMs);
+
+  await expect(page.locator('.jp-CodexChat-reconnectNotice')).toHaveCount(0);
+  await expect(page.getByText('Internal UI error while processing a server message')).toHaveCount(0);
+  expect(pageErrors).toEqual([]);
+  expect(codexConsoleErrors).toEqual([]);
+});

package/tests/e2e/mock-codex-cli-flood.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import sys
+import time
+import uuid
+from typing import Any
+
+
+def _emit(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload) + "\n")
+    sys.stdout.flush()
+
+
+def _run_app_server() -> int:
+    for raw_line in sys.stdin:
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method")
+        if method == "initialize" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {"capabilities": {}}})
+            continue
+        if method == "model/list" and req_id is not None:
+            _emit(
+                {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "data": [
+                            {
+                                "model": "gpt-5.3-codex",
+                                "displayName": "GPT-5.3 Codex",
+                                "supportedReasoningEfforts": ["low", "medium", "high"],
+                                "defaultReasoningEffort": "high",
+                            }
+                        ]
+                    },
+                }
+            )
+            continue
+        if method == "shutdown" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {}})
+            continue
+
+    return 0
+
+
+def _int_env(name: str, default: int, minimum: int) -> int:
+    raw = os.environ.get(name, str(default)).strip()
+    try:
+        value = int(raw)
+    except ValueError:
+        value = default
+    return max(minimum, value)
+
+
+def _run_exec_mode() -> int:
+    event_count = _int_env("MOCK_CODEX_EVENT_COUNT", 320, 20)
+    event_delay_ms = _int_env("MOCK_CODEX_EVENT_DELAY_MS", 20, 0)
+    chunk_words = _int_env("MOCK_CODEX_CHUNK_WORDS", 14, 4)
+
+    exit_code_raw = os.environ.get("MOCK_CODEX_EXIT_CODE", "0").strip()
+    try:
+        exit_code = int(exit_code_raw)
+    except ValueError:
+        exit_code = 0
+
+    prompt = sys.stdin.read().strip()
+    prompt_preview = prompt[:120] if prompt else "(empty prompt)"
+    repeated = " ".join(["analysis"] * chunk_words)
+    thread_id = f"mock-thread-{uuid.uuid4().hex[:12]}"
+
+    _emit({"type": "thread.started", "thread_id": thread_id})
+    _emit({"type": "item.started", "item": {"type": "reasoning", "title": "Long reasoning started"}})
+
+    for idx in range(event_count):
+        step = idx + 1
+        _emit(
+            {
+                "type": "item.completed",
+                "item": {
+                    "type": "agent_message",
+                    "text": f"[{step}/{event_count}] {prompt_preview} :: {repeated}",
+                },
+            }
+        )
+        _emit(
+            {
+                "type": "item.started",
+                "item": {"type": "command", "title": f"Tool step {step} started", "command": f"python -m check {step}"},
+            }
+        )
+        _emit(
+            {
+                "type": "item.completed",
+                "item": {
+                    "type": "command",
+                    "title": f"Tool step {step} completed",
+                    "command": f"python -m check {step}",
+                    "exit_code": 0,
+                },
+            }
+        )
+        if event_delay_ms > 0:
+            time.sleep(event_delay_ms / 1000.0)
+
+    _emit({"type": "item.completed", "item": {"type": "reasoning", "title": "Long reasoning completed"}})
+    return exit_code
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+    if len(argv) >= 1 and argv[0] == "app-server":
+        return _run_app_server()
+    return _run_exec_mode()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/tests/e2e/mock-codex-cli-prompt-echo.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+import json
+import sys
+import uuid
+from typing import Any
+
+
+def _emit(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload) + "\n")
+    sys.stdout.flush()
+
+
+def _run_app_server() -> int:
+    for raw_line in sys.stdin:
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method")
+        if method == "initialize" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {"capabilities": {}}})
+            continue
+        if method == "model/list" and req_id is not None:
+            _emit(
+                {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "data": [
+                            {
+                                "model": "mock-gpt",
+                                "displayName": "Mock GPT",
+                                "supportedReasoningEfforts": ["low", "medium", "high"],
+                                "defaultReasoningEffort": "medium",
+                            }
+                        ]
+                    },
+                }
+            )
+            continue
+        if method == "shutdown" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {}})
+            continue
+
+    return 0
+
+
+def _run_exec_mode() -> int:
+    prompt = sys.stdin.read()
+    thread_id = f"mock-thread-{uuid.uuid4().hex[:12]}"
+    head = prompt[:800]
+    tail = prompt[-800:] if prompt else ""
+
+    _emit({"type": "thread.started", "thread_id": thread_id})
+    _emit(
+        {
+            "type": "item.completed",
+            "item": {
+                "type": "agent_message",
+                "text": (
+                    "PROMPT_HEAD_START\n"
+                    f"{head}\n"
+                    "PROMPT_HEAD_END\n"
+                    "PROMPT_TAIL_START\n"
+                    f"{tail}\n"
+                    "PROMPT_TAIL_END"
+                ),
+            },
+        }
+    )
+    return 0
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+    if len(argv) >= 1 and argv[0] == "app-server":
+        return _run_app_server()
+    return _run_exec_mode()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/tests/e2e/mock-codex-cli.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import sys
+import time
+import uuid
+from typing import Any
+
+
+def _emit(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload) + "\n")
+    sys.stdout.flush()
+
+
+def _run_app_server() -> int:
+    for raw_line in sys.stdin:
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method")
+        if method == "initialize" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {"capabilities": {}}})
+            continue
+        if method == "model/list" and req_id is not None:
+            _emit(
+                {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "data": [
+                            {
+                                "model": "mock-gpt",
+                                "displayName": "Mock GPT",
+                                "supportedReasoningEfforts": ["low", "medium", "high"],
+                                "defaultReasoningEffort": "medium",
+                            }
+                        ]
+                    },
+                }
+            )
+            continue
+        if method == "shutdown" and req_id is not None:
+            _emit({"jsonrpc": "2.0", "id": req_id, "result": {}})
+            continue
+
+    return 0
+
+
+def _run_exec_mode() -> int:
+    try:
+        delay_ms = int(os.environ.get("MOCK_CODEX_DELAY_MS", "2600"))
+    except ValueError:
+        delay_ms = 2600
+    delay_ms = max(200, delay_ms)
+    exit_code_raw = os.environ.get("MOCK_CODEX_EXIT_CODE", "0")
+    try:
+        exit_code = int(exit_code_raw)
+    except ValueError:
+        exit_code = 0
+
+    prompt = sys.stdin.read().strip()
+    thread_id = f"mock-thread-{uuid.uuid4().hex[:12]}"
+
+    _emit({"type": "thread.started", "thread_id": thread_id})
+    _emit({"type": "item.started", "item": {"type": "reasoning", "title": "Mock run started"}})
+    time.sleep(delay_ms / 2000.0)
+    _emit(
+        {
+            "type": "item.completed",
+            "item": {
+                "type": "agent_message",
+                "text": f"Mock response for: {prompt[:120] if prompt else '(empty prompt)'}",
+            },
+        }
+    )
+    time.sleep(delay_ms / 2000.0)
+    return exit_code
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+    if len(argv) >= 1 and argv[0] == "app-server":
+        return _run_app_server()
+    return _run_exec_mode()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())