jupyterlab_ai_code_assistants_extension 1.0.29 → 1.0.31

package/README.md

@@ -30,6 +30,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload
 - **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
 - **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated
+- **Your terminal's `claude -c` follows the panel** (Claude) - switching to or launching a conversation makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete and per-row open and copy-id buttons
 - **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's `codex fork`, server-side copies for Kimi and Gemini) behind the same menu item
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus

package/lib/index.js

@@ -64,18 +64,34 @@ const plugin = {
         let status = null;
         let settings = null;
         let sidebar = DEFAULT_SIDEBAR;
+        let probeGeneration = 0;
         /** Ask the server which providers exist and which of their binaries are on
-         * PATH. A failure leaves the extension activated with no panels - never a
-         * dialog, and never a thrown activation. */
+         * PATH. An unsuperseded failure leaves the extension activated with no
+         * panels until a later probe succeeds - never a dialog, never a thrown
+         * activation.
+         *
+         * Probes overlap: a probe can outlive one issued after it, so verdicts do
+         * not arrive in the order they were asked for. A ROSTER is always written,
+         * whichever settles last - both are answers from the same server, and the
+         * loser is at worst one client deadline stale (DEF-125). A FAILURE is not an answer, so it
+         * is written only while no newer probe has been issued; otherwise a
+         * timeout could discard a roster the server has since confirmed, undocking
+         * every panel while it is healthy (DEF-121). No request is suppressed. */
         const probeStatus = async () => {
+            const mine = ++probeGeneration;
             try {
                 status = await requestAPI('status', serverSettings, {
                     cache: 'no-store'
                 });
             }
             catch (err) {
-                console.warn(`${LOG_PREFIX} status probe failed; no assistant panels will be docked.`, err);
-                status = null;
+                // No cadence named here: this also prints from the activation probe,
+                // and neither the interval nor the wake listeners are armed until
+                // after `await migrate()` below (DEF-122).
+                console.warn(`${LOG_PREFIX} status probe failed; panels dock again once a later probe succeeds.`, err);
+                if (mine === probeGeneration) {
+                    status = null;
+                }
             }
         };
         const statusFor = (id) => { var _a, _b; return (_b = (_a = status === null || status === void 0 ? void 0 : status.providers) === null || _a === void 0 ? void 0 : _a.find(p => p.id === id)) !== null && _b !== void 0 ? _b : null; };
@@ -306,6 +322,21 @@ const plugin = {
         window.setInterval(() => {
             void probeStatus().then(reconcile);
         }, STATUS_INTERVAL_MS);
+        // A suspended network stack - laptop asleep, tab backgrounded - is exactly
+        // when the probe fails, and the slow cadence above would leave the sidebar
+        // panel-less for up to a minute after the machine comes back. A wake fires
+        // both events, so it costs two probes; deliberately, because a guard that
+        // let the second join the first answered the wake with a request issued
+        // before it, and starved the interval above of its own tick (DEF-117).
+        const reprobe = () => {
+            void probeStatus().then(reconcile);
+        };
+        window.addEventListener('online', reprobe);
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                reprobe();
+            }
+        });
         console.log(`${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.0.29",
+    "version": "1.0.31",
     "description": "Jupyterlab extension to replace individual jupyterlab_*_code_extension and integrate into one, that offers joint capability, joint settings page and individual right toolbar panels per code assistant, with the ability in settings to decide which code assistant support is on (default - all are enabled)",
     "keywords": [
         "jupyter",

package/src/index.ts

@@ -116,20 +116,37 @@ const plugin: JupyterFrontEndPlugin<void> = {
     let settings: ISettingRegistry.ISettings | null = null;
     let sidebar: Sidebar = DEFAULT_SIDEBAR;
 
+    let probeGeneration = 0;
+
     /** Ask the server which providers exist and which of their binaries are on
-     * PATH. A failure leaves the extension activated with no panels - never a
-     * dialog, and never a thrown activation. */
+     * PATH. An unsuperseded failure leaves the extension activated with no
+     * panels until a later probe succeeds - never a dialog, never a thrown
+     * activation.
+     *
+     * Probes overlap: a probe can outlive one issued after it, so verdicts do
+     * not arrive in the order they were asked for. A ROSTER is always written,
+     * whichever settles last - both are answers from the same server, and the
+     * loser is at worst one client deadline stale (DEF-125). A FAILURE is not an answer, so it
+     * is written only while no newer probe has been issued; otherwise a
+     * timeout could discard a roster the server has since confirmed, undocking
+     * every panel while it is healthy (DEF-121). No request is suppressed. */
     const probeStatus = async (): Promise<void> => {
+      const mine = ++probeGeneration;
       try {
         status = await requestAPI<IStatusResponse>('status', serverSettings, {
           cache: 'no-store'
         });
       } catch (err) {
+        // No cadence named here: this also prints from the activation probe,
+        // and neither the interval nor the wake listeners are armed until
+        // after `await migrate()` below (DEF-122).
         console.warn(
-          `${LOG_PREFIX} status probe failed; no assistant panels will be docked.`,
+          `${LOG_PREFIX} status probe failed; panels dock again once a later probe succeeds.`,
           err
         );
-        status = null;
+        if (mine === probeGeneration) {
+          status = null;
+        }
       }
     };
 
@@ -392,6 +409,22 @@ const plugin: JupyterFrontEndPlugin<void> = {
       void probeStatus().then(reconcile);
     }, STATUS_INTERVAL_MS);
 
+    // A suspended network stack - laptop asleep, tab backgrounded - is exactly
+    // when the probe fails, and the slow cadence above would leave the sidebar
+    // panel-less for up to a minute after the machine comes back. A wake fires
+    // both events, so it costs two probes; deliberately, because a guard that
+    // let the second join the first answered the wake with a request issued
+    // before it, and starved the interval above of its own tick (DEF-117).
+    const reprobe = (): void => {
+      void probeStatus().then(reconcile);
+    };
+    window.addEventListener('online', reprobe);
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'visible') {
+        reprobe();
+      }
+    });
+
     console.log(
       `${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`
     );