jupyterlab_ai_code_assistants_extension 1.2.45 → 1.2.50

package/README.md

@@ -47,6 +47,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Conflict-safe upgrade** - if a retired standalone extension is still installed, its panel wins and this extension stands down for that assistant instead of showing a duplicate
 - **DeepSeek in the browser** - the DeepSeek Harness has no terminal chat; its panel lists the projects under `~/.dsh/sessions` (or `$DSH_HOME`) and `Open Web UI` starts `dsh --profile web --no-open --port 0` in the project's terminal, which prints the URL to open. The conversation is then chosen in the harness's own browser UI; branching and deleting work from the panel as for every other assistant. The URL is on the machine running JupyterLab, so a remote server needs a port forward to reach it
 - **Auto-disabled when absent** - an assistant whose CLI is not on `PATH` does not show a panel
+- **Open Callback** - when an assistant's login sends your browser to an `http://127.0.0.1:...` link that fails to load, because the login is waiting on the machine running JupyterLab, run `Open Callback` from the command palette and paste the link; the Jupyter server requests it for you, and the popup says whether the login accepted it. Only `http` links to that machine's own loopback are accepted
 
 ## Requirements
 

package/lib/core/callback.d.ts

@@ -0,0 +1,15 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { TranslationBundle } from '@jupyterlab/translation';
+/** The command that delivers a pasted login callback link. */
+export declare const CALLBACK_COMMAND = "open:callback";
+/**
+ * Register the command that sends a pasted login callback link to the login
+ * waiting on the Jupyter server.
+ *
+ * A CLI login waits for its OAuth redirect on the server's own loopback, but
+ * the browser that follows the redirect runs on the user's machine, where that
+ * address is another host - so the page fails to load, with the link left in
+ * the address bar. Pasted here, the server makes the request instead.
+ */
+export declare function addCallbackCommand(app: JupyterFrontEnd, palette: ICommandPalette | null, category: string, trans: TranslationBundle): void;

package/lib/core/callback.js

@@ -0,0 +1,140 @@
+import { Dialog, Notification } from '@jupyterlab/apputils';
+import { Widget } from '@lumino/widgets';
+import { requestAPI } from './request';
+/** The command that delivers a pasted login callback link. */
+export const CALLBACK_COMMAND = 'open:callback';
+async function deliver(url, app, trans) {
+    try {
+        const answer = await requestAPI('callback', app.serviceManager.serverSettings, { method: 'POST', body: JSON.stringify({ url }) });
+        return answer.status < 400
+            ? {
+                level: 'success',
+                message: trans.__('The login accepted the link. Check the terminal where the login is running.')
+            }
+            : {
+                level: 'warning',
+                message: trans.__('The login did not accept this link. Start the login again and paste the new link.')
+            };
+    }
+    catch (err) {
+        const code = err instanceof Error ? err.message : '';
+        return {
+            level: 'error',
+            message: code === 'callback_not_loopback'
+                ? trans.__('This link cannot be used. It must start with http://127.0.0.1 or http://localhost.')
+                : code === 'callback_unreachable'
+                    ? trans.__('No login is waiting for this link. Start the login again and paste the new link.')
+                    : trans.__('The link could not be sent to the Jupyter server. Try again.')
+        };
+    }
+}
+/** The popup's body: the link field and, below it, what the last send came
+ * to. */
+class CallbackForm extends Widget {
+    constructor(trans) {
+        super();
+        this.addClass('jp-AiAssistantsCallback');
+        const label = document.createElement('label');
+        label.textContent = trans.__('Callback link from the browser address bar');
+        this._input = document.createElement('input');
+        this._input.type = 'text';
+        this._input.className = 'jp-mod-styled';
+        this._input.placeholder = 'http://127.0.0.1:1455/auth/callback?code=...';
+        label.appendChild(this._input);
+        this._status = document.createElement('div');
+        this._status.className = 'jp-AiAssistantsCallback-status';
+        this._status.setAttribute('role', 'status');
+        this.node.append(label, this._status);
+    }
+    get url() {
+        return this._input.value.trim();
+    }
+    report(level, message) {
+        this._status.dataset.level = level;
+        this._status.textContent = message;
+    }
+}
+/** OK sends the link and leaves the window open, so the result is read - and
+ * a refused link replaced - in the same place. Close and Escape end it. */
+class CallbackDialog extends Dialog {
+    constructor(_form, _send, _trans) {
+        super({
+            title: _trans.__('Open Callback'),
+            body: _form,
+            buttons: [
+                Dialog.cancelButton({ label: _trans.__('Close') }),
+                Dialog.okButton({ label: _trans.__('OK') })
+            ],
+            defaultButton: 1,
+            focusNodeSelector: 'input'
+        });
+        this._form = _form;
+        this._send = _send;
+        this._trans = _trans;
+        this._sending = false;
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+            return;
+        }
+        void this._deliver();
+    }
+    async _deliver() {
+        const url = this._form.url;
+        if (this._sending) {
+            return;
+        }
+        if (!url) {
+            this._form.report('error', this._trans.__('Paste the link first.'));
+            return;
+        }
+        this._sending = true;
+        this._form.report('pending', this._trans.__('Sending the link...'));
+        const outcome = await this._send(url);
+        this._sending = false;
+        if (!this.isDisposed) {
+            this._form.report(outcome.level, outcome.message);
+        }
+    }
+}
+/**
+ * Register the command that sends a pasted login callback link to the login
+ * waiting on the Jupyter server.
+ *
+ * A CLI login waits for its OAuth redirect on the server's own loopback, but
+ * the browser that follows the redirect runs on the user's machine, where that
+ * address is another host - so the page fails to load, with the link left in
+ * the address bar. Pasted here, the server makes the request instead.
+ */
+export function addCallbackCommand(app, palette, category, trans) {
+    app.commands.addCommand(CALLBACK_COMMAND, {
+        label: trans.__('Open Callback'),
+        caption: trans.__('Send a pasted login callback link to the login waiting on the Jupyter server'),
+        describedBy: {
+            args: {
+                type: 'object',
+                properties: {
+                    url: {
+                        type: 'string',
+                        description: 'The callback link. Asked for in a popup when absent.'
+                    }
+                }
+            }
+        },
+        execute: async (args) => {
+            const send = (url) => deliver(url, app, trans);
+            const given = typeof args.url === 'string' ? args.url.trim() : '';
+            if (given) {
+                // No popup to write into, so the result is a toast.
+                const outcome = await send(given);
+                Notification[outcome.level](outcome.message, {
+                    autoClose: outcome.level === 'success' ? 4000 : 8000
+                });
+                return;
+            }
+            await new CallbackDialog(new CallbackForm(trans), send, trans).launch();
+        }
+    });
+    palette === null || palette === void 0 ? void 0 : palette.addItem({ command: CALLBACK_COMMAND, category });
+}

package/lib/core/icons.js

@@ -103,15 +103,16 @@ export const filterIcon = new LabIcon({
     name: `${ICON_PREFIX}:filter`,
     svgstr: filterSvgStr
 });
-// Row status mark - one filled circle, drawn for a conversation that is live
-// or under remote control. An SVG rather than a rounded span so its colour is
-// a CSS `fill` on the circle itself, the way every other glyph here is
-// recoloured through its class (DEF-PANE-174). The circle carries no `fill`
-// attribute: the stylesheet is the single source of that colour, and a
-// presentation attribute here would be a second one to keep in step
-// (DEF-PANE-179).
+// Row status mark - a light, drawn for a conversation that is live or under
+// remote control: a 6px circle over the 8px disc that casts its halo. An SVG
+// rather than a rounded span so each colour is a CSS `fill` on the circle
+// itself, the way every other glyph here is recoloured through its class
+// (DEF-PANE-174). The circles carry no `fill` attribute: the stylesheet is the
+// single source of those colours, and a presentation attribute here would be
+// a second one to keep in step (DEF-PANE-179).
 const statusDotSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
-  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotHalo" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="6"/>
 </svg>`;
 export const statusDotIcon = new LabIcon({
     name: `${ICON_PREFIX}:status-dot`,

package/lib/index.js

@@ -1,11 +1,12 @@
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
-import { Notification } from '@jupyterlab/apputils';
+import { ICommandPalette, Notification } from '@jupyterlab/apputils';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ILauncher } from '@jupyterlab/launcher';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
+import { addCallbackCommand } from './core/callback';
 import { launcherTileIcon, providerIcon } from './core/icons';
 import { DEFAULT_RECENT_LIMIT } from './core/limits';
 import { AssistantSessionsPanel, DEFAULT_PRESENTATION_MODE, commandId, panelWidgetId } from './core/panel';
@@ -40,9 +41,10 @@ const plugin = {
         IDefaultFileBrowser,
         IColourfulTabs,
         ILauncher,
-        ITranslator
+        ITranslator,
+        ICommandPalette
     ],
-    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs, launcher, translator) => {
+    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs, launcher, translator, palette) => {
         console.log('JupyterLab extension jupyterlab_ai_code_assistants_extension is activated!');
         // Every user-visible string in the panels goes through this bundle.
         // `ITranslator` is optional, and the null translator returns each string
@@ -51,6 +53,7 @@ const plugin = {
         // A duplicate id throws here, at registration, rather than surfacing later
         // as two panels quietly fighting over one widget id.
         const registry = new ProviderRegistry(PROVIDERS);
+        addCallbackCommand(app, palette !== null && palette !== void 0 ? palette : null, LAUNCHER_CATEGORY, trans);
         const serverSettings = app.serviceManager.serverSettings;
         const live = new Map();
         const warnedUnknown = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.45",
+    "version": "1.2.50",
     "description": "A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting.",
     "keywords": [
         "jupyter",

package/src/__tests__/callback.spec.ts

@@ -0,0 +1,258 @@
+/**
+ * The Open Callback command: a pasted login callback link, handed to the
+ * server. The server's side - loopback only, one request, nothing logged - is
+ * `tests/test_callback.py`; this is the popup, the request and what the user
+ * is told.
+ */
+
+// ESM-only packages that JupyterLab's apputils pulls in and jest cannot parse.
+jest.mock('@jupyter/react-components', () => ({}));
+jest.mock('@jupyter/web-components', () => ({
+  addJupyterLabThemeChangeListener: () => undefined,
+  applyJupyterTheme: () => undefined,
+  jpButton: () => undefined,
+  jpToolbar: () => undefined,
+  provideJupyterDesignSystem: () => ({ register: () => undefined })
+}));
+jest.mock('../core/request', () => ({
+  requestAPI: jest.fn()
+}));
+
+import { Notification } from '@jupyterlab/apputils';
+import { nullTranslator } from '@jupyterlab/translation';
+import { CommandRegistry } from '@lumino/commands';
+
+import { CALLBACK_COMMAND, addCallbackCommand } from '../core/callback';
+import { requestAPI } from '../core/request';
+
+const request = requestAPI as jest.Mock;
+const LINK = 'http://127.0.0.1:1455/auth/callback?code=one-time&state=s';
+
+/** One macrotask: `Dialog.launch` attaches the popup after its own awaits. */
+const settle = (): Promise<void> =>
+  new Promise(resolve => setTimeout(resolve, 0));
+
+function setup(): {
+  commands: CommandRegistry;
+  added: { command: string; category: string }[];
+  serverSettings: object;
+} {
+  const commands = new CommandRegistry();
+  const serverSettings = {};
+  const added: { command: string; category: string }[] = [];
+  addCallbackCommand(
+    { commands, serviceManager: { serverSettings } } as any,
+    { addItem: (item: any) => added.push(item) } as any,
+    'AI Assistants',
+    nullTranslator.load('test')
+  );
+  return { commands, added, serverSettings };
+}
+
+interface IPopup {
+  /** Settles when the popup has closed. */
+  closed: Promise<unknown>;
+  input: HTMLInputElement;
+  status: HTMLElement;
+  ok: HTMLElement;
+  close: HTMLElement;
+}
+
+async function openPopup(commands: CommandRegistry): Promise<IPopup> {
+  const closed = commands.execute(CALLBACK_COMMAND);
+  await settle();
+  const node = document.querySelector('.jp-Dialog') as HTMLElement;
+  return {
+    closed,
+    input: node.querySelector(
+      '.jp-AiAssistantsCallback input'
+    ) as HTMLInputElement,
+    status: node.querySelector(
+      '.jp-AiAssistantsCallback-status'
+    ) as HTMLElement,
+    ok: node.querySelector('.jp-mod-accept') as HTMLElement,
+    close: node.querySelector('.jp-mod-reject') as HTMLElement
+  };
+}
+
+/** No status code, no server error code and never the link, which carries a
+ * login code. */
+function expectPlainWords(text: string): void {
+  expect(text).not.toMatch(
+    /callback_|HTTP|\b[45]\d\d\b|Internal Server Error|one-time/
+  );
+}
+
+describe('the Open Callback command', () => {
+  let success: jest.SpyInstance;
+  let error: jest.SpyInstance;
+
+  beforeEach(() => {
+    request.mockReset();
+    success = jest.spyOn(Notification, 'success').mockReturnValue('' as any);
+    error = jest.spyOn(Notification, 'error').mockReturnValue('' as any);
+  });
+
+  afterEach(async () => {
+    // A popup left open would hold every later one in JupyterLab's queue.
+    (
+      document.querySelector('.jp-Dialog .jp-mod-reject') as HTMLElement
+    )?.click();
+    await settle();
+    jest.restoreAllMocks();
+  });
+
+  it('is on the command palette under the assistants category', () => {
+    const { commands, added } = setup();
+    expect(commands.hasCommand(CALLBACK_COMMAND)).toBe(true);
+    expect(commands.label(CALLBACK_COMMAND)).toBe('Open Callback');
+    expect(added).toEqual([
+      { command: CALLBACK_COMMAND, category: 'AI Assistants' }
+    ]);
+  });
+
+  it('registers without a palette', () => {
+    const commands = new CommandRegistry();
+    addCallbackCommand(
+      { commands, serviceManager: { serverSettings: {} } } as any,
+      null,
+      'AI Assistants',
+      nullTranslator.load('test')
+    );
+    expect(commands.hasCommand(CALLBACK_COMMAND)).toBe(true);
+  });
+
+  it('OK sends the trimmed link and writes the result under the field, window still open', async () => {
+    const { commands, serverSettings } = setup();
+    request.mockResolvedValue({ status: 302 });
+    const popup = await openPopup(commands);
+
+    popup.input.value = `  ${LINK}\n`;
+    popup.ok.click();
+    await settle();
+
+    expect(request).toHaveBeenCalledWith('callback', serverSettings, {
+      method: 'POST',
+      body: JSON.stringify({ url: LINK })
+    });
+    expect(popup.status.dataset.level).toBe('success');
+    expect(popup.status.textContent).toContain('The login accepted the link');
+    expectPlainWords(popup.status.textContent ?? '');
+    // Read in the popup, not in a toast, and the popup is still there.
+    expect(success).not.toHaveBeenCalled();
+    expect(document.querySelector('.jp-Dialog')).not.toBeNull();
+
+    popup.close.click();
+    await popup.closed;
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
+  });
+
+  it('Enter in the field sends, as OK does', async () => {
+    const { commands } = setup();
+    request.mockResolvedValue({ status: 200 });
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.input.dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })
+    );
+    await settle();
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(popup.status.dataset.level).toBe('success');
+  });
+
+  it('a refused link is replaced and sent again in the same window', async () => {
+    const { commands } = setup();
+    request
+      .mockRejectedValueOnce(new Error('callback_unreachable'))
+      .mockResolvedValueOnce({ status: 302 });
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.ok.click();
+    await settle();
+    expect(popup.status.dataset.level).toBe('error');
+
+    popup.input.value = LINK.replace('one-time', 'second');
+    popup.ok.click();
+    await settle();
+    expect(request).toHaveBeenCalledTimes(2);
+    expect(popup.status.dataset.level).toBe('success');
+  });
+
+  it('OK on an empty field sends nothing and says so', async () => {
+    const { commands } = setup();
+    const popup = await openPopup(commands);
+
+    popup.input.value = '   ';
+    popup.ok.click();
+    await settle();
+
+    expect(request).not.toHaveBeenCalled();
+    expect(popup.status.textContent).toBe('Paste the link first.');
+  });
+
+  it('Close sends nothing', async () => {
+    const { commands } = setup();
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.close.click();
+    await popup.closed;
+
+    expect(request).not.toHaveBeenCalled();
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
+  });
+
+  it.each([
+    [
+      'the login answers with an error',
+      () => Promise.resolve({ status: 400 }),
+      'warning',
+      'The login did not accept this link'
+    ],
+    [
+      'the link is not a loopback link',
+      () => Promise.reject(new Error('callback_not_loopback')),
+      'error',
+      'It must start with http://127.0.0.1 or http://localhost'
+    ],
+    [
+      'no login is listening',
+      () => Promise.reject(new Error('callback_unreachable')),
+      'error',
+      'No login is waiting for this link'
+    ],
+    [
+      'the server fails',
+      () => Promise.reject(new Error('Internal Server Error')),
+      'error',
+      'The link could not be sent to the Jupyter server'
+    ]
+  ])('says in plain words that %s', async (_case, answer, level, expected) => {
+    const { commands } = setup();
+    request.mockImplementation(answer);
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.ok.click();
+    await settle();
+
+    expect(popup.status.dataset.level).toBe(level);
+    expect(popup.status.textContent).toContain(expected);
+    expectPlainWords(popup.status.textContent ?? '');
+  });
+
+  it('given the link as an argument, opens no popup and reports in a toast', async () => {
+    const { commands } = setup();
+    request.mockRejectedValue(new Error('callback_unreachable'));
+
+    await commands.execute(CALLBACK_COMMAND, { url: LINK });
+
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(error).toHaveBeenCalledTimes(1);
+    expectPlainWords(String(error.mock.calls[0][0]));
+  });
+});

package/src/__tests__/index.spec.ts

@@ -480,6 +480,12 @@ describe('ACC-PROV - the activation contract', () => {
       ])
     );
 
+  it('registers the Open Callback command at activation', async () => {
+    const live = await activate();
+    expect(live.app.commands.hasCommand('open:callback')).toBe(true);
+    live.docked.forEach(widget => widget.dispose());
+  });
+
   it('ACC-PROV-10, ACC-PROV-11 - each panel carries its own widget id and registers it for restore', async () => {
     const live = await activate();
     // How this fails: pass a constant to `restorer.add` and two panels claim

package/src/core/callback.ts

@@ -0,0 +1,189 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { Dialog, ICommandPalette, Notification } from '@jupyterlab/apputils';
+import { TranslationBundle } from '@jupyterlab/translation';
+import { Widget } from '@lumino/widgets';
+
+import { requestAPI } from './request';
+
+/** The command that delivers a pasted login callback link. */
+export const CALLBACK_COMMAND = 'open:callback';
+
+/** What a delivery came to, in words for the user. Never the link, which
+ * carries a login code, and never a status code. */
+interface IOutcome {
+  level: 'success' | 'warning' | 'error';
+  message: string;
+}
+
+async function deliver(
+  url: string,
+  app: JupyterFrontEnd,
+  trans: TranslationBundle
+): Promise<IOutcome> {
+  try {
+    const answer = await requestAPI<{ status: number }>(
+      'callback',
+      app.serviceManager.serverSettings,
+      { method: 'POST', body: JSON.stringify({ url }) }
+    );
+    return answer.status < 400
+      ? {
+          level: 'success',
+          message: trans.__(
+            'The login accepted the link. Check the terminal where the login is running.'
+          )
+        }
+      : {
+          level: 'warning',
+          message: trans.__(
+            'The login did not accept this link. Start the login again and paste the new link.'
+          )
+        };
+  } catch (err) {
+    const code = err instanceof Error ? err.message : '';
+    return {
+      level: 'error',
+      message:
+        code === 'callback_not_loopback'
+          ? trans.__(
+              'This link cannot be used. It must start with http://127.0.0.1 or http://localhost.'
+            )
+          : code === 'callback_unreachable'
+            ? trans.__(
+                'No login is waiting for this link. Start the login again and paste the new link.'
+              )
+            : trans.__(
+                'The link could not be sent to the Jupyter server. Try again.'
+              )
+    };
+  }
+}
+
+/** The popup's body: the link field and, below it, what the last send came
+ * to. */
+class CallbackForm extends Widget {
+  constructor(trans: TranslationBundle) {
+    super();
+    this.addClass('jp-AiAssistantsCallback');
+    const label = document.createElement('label');
+    label.textContent = trans.__('Callback link from the browser address bar');
+    this._input = document.createElement('input');
+    this._input.type = 'text';
+    this._input.className = 'jp-mod-styled';
+    this._input.placeholder = 'http://127.0.0.1:1455/auth/callback?code=...';
+    label.appendChild(this._input);
+    this._status = document.createElement('div');
+    this._status.className = 'jp-AiAssistantsCallback-status';
+    this._status.setAttribute('role', 'status');
+    this.node.append(label, this._status);
+  }
+
+  get url(): string {
+    return this._input.value.trim();
+  }
+
+  report(level: IOutcome['level'] | 'pending', message: string): void {
+    this._status.dataset.level = level;
+    this._status.textContent = message;
+  }
+
+  private _input: HTMLInputElement;
+  private _status: HTMLDivElement;
+}
+
+/** OK sends the link and leaves the window open, so the result is read - and
+ * a refused link replaced - in the same place. Close and Escape end it. */
+class CallbackDialog extends Dialog<void> {
+  constructor(
+    private _form: CallbackForm,
+    private _send: (url: string) => Promise<IOutcome>,
+    private _trans: TranslationBundle
+  ) {
+    super({
+      title: _trans.__('Open Callback'),
+      body: _form,
+      buttons: [
+        Dialog.cancelButton({ label: _trans.__('Close') }),
+        Dialog.okButton({ label: _trans.__('OK') })
+      ],
+      defaultButton: 1,
+      focusNodeSelector: 'input'
+    });
+  }
+
+  resolve(index?: number): void {
+    if (index === 0) {
+      super.resolve(index);
+      return;
+    }
+    void this._deliver();
+  }
+
+  private async _deliver(): Promise<void> {
+    const url = this._form.url;
+    if (this._sending) {
+      return;
+    }
+    if (!url) {
+      this._form.report('error', this._trans.__('Paste the link first.'));
+      return;
+    }
+    this._sending = true;
+    this._form.report('pending', this._trans.__('Sending the link...'));
+    const outcome = await this._send(url);
+    this._sending = false;
+    if (!this.isDisposed) {
+      this._form.report(outcome.level, outcome.message);
+    }
+  }
+
+  private _sending = false;
+}
+
+/**
+ * Register the command that sends a pasted login callback link to the login
+ * waiting on the Jupyter server.
+ *
+ * A CLI login waits for its OAuth redirect on the server's own loopback, but
+ * the browser that follows the redirect runs on the user's machine, where that
+ * address is another host - so the page fails to load, with the link left in
+ * the address bar. Pasted here, the server makes the request instead.
+ */
+export function addCallbackCommand(
+  app: JupyterFrontEnd,
+  palette: ICommandPalette | null,
+  category: string,
+  trans: TranslationBundle
+): void {
+  app.commands.addCommand(CALLBACK_COMMAND, {
+    label: trans.__('Open Callback'),
+    caption: trans.__(
+      'Send a pasted login callback link to the login waiting on the Jupyter server'
+    ),
+    describedBy: {
+      args: {
+        type: 'object',
+        properties: {
+          url: {
+            type: 'string',
+            description: 'The callback link. Asked for in a popup when absent.'
+          }
+        }
+      }
+    },
+    execute: async args => {
+      const send = (url: string): Promise<IOutcome> => deliver(url, app, trans);
+      const given = typeof args.url === 'string' ? args.url.trim() : '';
+      if (given) {
+        // No popup to write into, so the result is a toast.
+        const outcome = await send(given);
+        Notification[outcome.level](outcome.message, {
+          autoClose: outcome.level === 'success' ? 4000 : 8000
+        });
+        return;
+      }
+      await new CallbackDialog(new CallbackForm(trans), send, trans).launch();
+    }
+  });
+  palette?.addItem({ command: CALLBACK_COMMAND, category });
+}

package/src/core/icons.ts

@@ -126,15 +126,16 @@ export const filterIcon = new LabIcon({
   svgstr: filterSvgStr
 });
 
-// Row status mark - one filled circle, drawn for a conversation that is live
-// or under remote control. An SVG rather than a rounded span so its colour is
-// a CSS `fill` on the circle itself, the way every other glyph here is
-// recoloured through its class (DEF-PANE-174). The circle carries no `fill`
-// attribute: the stylesheet is the single source of that colour, and a
-// presentation attribute here would be a second one to keep in step
-// (DEF-PANE-179).
+// Row status mark - a light, drawn for a conversation that is live or under
+// remote control: a 6px circle over the 8px disc that casts its halo. An SVG
+// rather than a rounded span so each colour is a CSS `fill` on the circle
+// itself, the way every other glyph here is recoloured through its class
+// (DEF-PANE-174). The circles carry no `fill` attribute: the stylesheet is the
+// single source of those colours, and a presentation attribute here would be
+// a second one to keep in step (DEF-PANE-179).
 const statusDotSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
-  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotHalo" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="6"/>
 </svg>`;
 
 export const statusDotIcon = new LabIcon({

package/src/index.ts

@@ -4,7 +4,7 @@ import {
   JupyterFrontEnd,
   JupyterFrontEndPlugin
 } from '@jupyterlab/application';
-import { Notification } from '@jupyterlab/apputils';
+import { ICommandPalette, Notification } from '@jupyterlab/apputils';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ILauncher } from '@jupyterlab/launcher';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
@@ -13,6 +13,7 @@ import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { IDisposable } from '@lumino/disposable';
 
+import { addCallbackCommand } from './core/callback';
 import { launcherTileIcon, providerIcon } from './core/icons';
 import { DEFAULT_RECENT_LIMIT } from './core/limits';
 import {
@@ -75,7 +76,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     IDefaultFileBrowser,
     IColourfulTabs,
     ILauncher,
-    ITranslator
+    ITranslator,
+    ICommandPalette
   ],
   activate: async (
     app: JupyterFrontEnd,
@@ -86,7 +88,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     fileBrowser: IDefaultFileBrowser | null,
     colourfulTabs: IColourfulTabs | null,
     launcher: ILauncher | null,
-    translator: ITranslator | null
+    translator: ITranslator | null,
+    palette: ICommandPalette | null
   ) => {
     console.log(
       'JupyterLab extension jupyterlab_ai_code_assistants_extension is activated!'
@@ -103,6 +106,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     // as two panels quietly fighting over one widget id.
     const registry = new ProviderRegistry(PROVIDERS);
 
+    addCallbackCommand(app, palette ?? null, LAUNCHER_CATEGORY, trans);
+
     const serverSettings = app.serviceManager.serverSettings;
     const live = new Map<string, ILivePanel>();
     const warnedUnknown = new Set<string>();

package/style/base.css

@@ -394,6 +394,15 @@
   fill: var(--jp-success-color1);
 }
 
+/* The 8px disc behind the 6px light. It is what casts the halo, so the halo
+   keeps the size it had when the light itself was 8px; fully opaque for that
+   reason, since a shadow is cast by alpha. The 1px of it that shows around the
+   light is painted as the halo looks at that point - the glow colour, dimmed -
+   so it reads as the halo's inner edge and not as a second dot. */
+.jp-AiAssistantsPanel-dotHalo {
+  fill: color-mix(in srgb, var(--jp-success-color1) 65%, black);
+}
+
 /* Light themes take a different dot, because both halves of the one above stop
    working there. JupyterLab stamps the theme's own `isLight` onto the body, so
    the switch is CSS and no TypeScript sees it.
@@ -426,6 +435,12 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotGlyph {
   fill: var(--md-green-500);
 }
 
+/* The mint ring's own colour: three passes saturate the ring at the disc's
+   edge, so undimmed mint is what the halo looks like there. */
+body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
+  fill: var(--md-green-200);
+}
+
 .jp-AiAssistantsPanel-dotPlaceholder {
   background-color: transparent;
 }
@@ -1001,3 +1016,40 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotGlyph {
 .jp-AiAssistantsPanel-row.jp-mod-stale .jp-AiAssistantsPanel-name {
   opacity: 0.65;
 }
+
+/* The Open Callback popup. A callback link runs to about 250 characters, so
+   the field takes the width a normal window can give it. */
+.jp-AiAssistantsCallback {
+  width: min(640px, 80vw);
+}
+
+.jp-AiAssistantsCallback label {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.jp-AiAssistantsCallback input {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+/* What the last send came to. The height is reserved, so the buttons do not
+   move when the text arrives. */
+.jp-AiAssistantsCallback-status {
+  min-height: 1.5em;
+  margin-top: 8px;
+  color: var(--jp-ui-font-color2);
+}
+
+.jp-AiAssistantsCallback-status[data-level='success'] {
+  color: var(--jp-success-color1);
+}
+
+.jp-AiAssistantsCallback-status[data-level='warning'] {
+  color: var(--jp-warn-color1);
+}
+
+.jp-AiAssistantsCallback-status[data-level='error'] {
+  color: var(--jp-error-color1);
+}