xtralab 0.11.1 → 0.12.0

package/lib/terminals/agentTerminals.d.ts

@@ -0,0 +1,63 @@
+import type { Terminal } from '@jupyterlab/services';
+import type { ITerminalTracker } from '@jupyterlab/terminal';
+import type { TranslationBundle } from '@jupyterlab/translation';
+import { ISignal } from '@lumino/signaling';
+import type { SessionRegistry } from './model';
+import type { IAgentTerminalSession, IAgentTerminals } from './tokens';
+/**
+ * The {@link IAgentTerminals} implementation: a read-only view over the
+ * terminals panel's {@link SessionRegistry} narrowed to sessions with a
+ * detection-confirmed coding agent, plus the "send a prompt into one"
+ * action. Lives in the `xtralab:terminals` plugin so the ask-agent popup
+ * (and any future caller) can target running agents without duplicating the
+ * detection plumbing.
+ */
+export declare class AgentTerminals implements IAgentTerminals {
+    constructor(options: AgentTerminals.IOptions);
+    sessions(): IAgentTerminalSession[];
+    get changed(): ISignal<IAgentTerminals, void>;
+    sendPrompt(name: string, prompt: string): Promise<void>;
+    private _findWidget;
+    private _onRegistryStateChanged;
+    private _registry;
+    private _tracker;
+    private _terminals;
+    private _detectCommands;
+    private _isAgentCommand;
+    private _trans;
+    private _changed;
+}
+/**
+ * A namespace for `AgentTerminals` statics.
+ */
+export declare namespace AgentTerminals {
+    /**
+     * Construction options for {@link AgentTerminals}.
+     */
+    interface IOptions {
+        /**
+         * The panel's session registry — the source of the session snapshot.
+         */
+        registry: SessionRegistry;
+        /**
+         * Tracker of open terminal widgets, to reuse an open tab's connection.
+         */
+        tracker: ITerminalTracker;
+        /**
+         * The terminal session manager, for validation and ad-hoc connections.
+         */
+        terminals: Terminal.IManager;
+        /**
+         * Names to detect — same list the registry polls with.
+         */
+        detectCommands: () => string[];
+        /**
+         * Whether a detected command belongs to a coding agent (not an editor).
+         */
+        isAgentCommand: (command: string) => boolean;
+        /**
+         * Translation bundle for the error messages thrown to callers.
+         */
+        trans: TranslationBundle;
+    }
+}

package/lib/terminals/agentTerminals.js

@@ -0,0 +1,157 @@
+import { Signal } from '@lumino/signaling';
+import { fetchRunningAgents } from './detection';
+/**
+ * Pause between pasting the prompt and pressing Enter, so the two reach the
+ * agent as separate PTY reads — the same shape as a human pasting and then
+ * submitting. Sent back to back, the server can coalesce both websocket
+ * messages into one read and the TUI would have to split the paste from the
+ * trailing Enter inside a single chunk.
+ */
+const PASTE_SUBMIT_DELAY_MS = 150;
+/**
+ * Bracketed-paste markers (`CSI 200~` / `CSI 201~`). The prompt is wrapped
+ * in these so the agent's TUI treats it as one pasted block — newlines
+ * insert into its input box instead of submitting the message at each line
+ * break. Every send target is a terminal where detection just confirmed a
+ * running coding agent, and the agent TUIs keep bracketed-paste mode on.
+ */
+const PASTE_OPEN = '\x1b[200~';
+const PASTE_CLOSE = '\x1b[201~';
+/**
+ * How long to wait for the session's websocket to reach `connected` before
+ * failing the send, so a server hiccup surfaces as an error notification
+ * rather than a silent hang.
+ */
+const CONNECT_TIMEOUT_MS = 10000;
+/**
+ * Resolve once `session` reports `connected`; reject with `timeoutMessage`
+ * after {@link CONNECT_TIMEOUT_MS}. Matches how the launcher waits before
+ * typing into a fresh terminal — writes sent while the websocket is still
+ * connecting disappear silently.
+ */
+function waitUntilConnected(session, timeoutMessage) {
+    if (session.connectionStatus === 'connected') {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            window.clearTimeout(timer);
+            session.connectionStatusChanged.disconnect(onStatus);
+        };
+        const onStatus = () => {
+            if (session.connectionStatus === 'connected') {
+                cleanup();
+                resolve();
+            }
+        };
+        const timer = window.setTimeout(() => {
+            cleanup();
+            reject(new Error(timeoutMessage));
+        }, CONNECT_TIMEOUT_MS);
+        session.connectionStatusChanged.connect(onStatus);
+    });
+}
+/**
+ * The {@link IAgentTerminals} implementation: a read-only view over the
+ * terminals panel's {@link SessionRegistry} narrowed to sessions with a
+ * detection-confirmed coding agent, plus the "send a prompt into one"
+ * action. Lives in the `xtralab:terminals` plugin so the ask-agent popup
+ * (and any future caller) can target running agents without duplicating the
+ * detection plumbing.
+ */
+export class AgentTerminals {
+    constructor(options) {
+        this._changed = new Signal(this);
+        this._registry = options.registry;
+        this._tracker = options.tracker;
+        this._terminals = options.terminals;
+        this._detectCommands = options.detectCommands;
+        this._isAgentCommand = options.isAgentCommand;
+        this._trans = options.trans;
+        this._registry.stateChanged.connect(this._onRegistryStateChanged, this);
+    }
+    sessions() {
+        const result = [];
+        for (const name of this._registry.sessionNames()) {
+            const command = this._registry.detectedCommandFor(name);
+            if (command === null || !this._isAgentCommand(command)) {
+                continue;
+            }
+            result.push({
+                name,
+                command,
+                label: this._registry.labelFor(name),
+                activity: this._registry.activityFor(name)
+            });
+        }
+        return result;
+    }
+    get changed() {
+        return this._changed;
+    }
+    async sendPrompt(name, prompt) {
+        // Re-validate against the server rather than trusting the caller's
+        // (possibly seconds-old) snapshot: the prompt is prose, and prose pasted
+        // into the shell prompt left behind by an exited agent would be
+        // *executed* on the Enter below.
+        await this._terminals.refreshRunning();
+        const alive = Array.from(this._terminals.running()).some(model => model.name === name);
+        if (!alive) {
+            throw new Error(this._trans.__('The terminal is no longer running.'));
+        }
+        const detected = await fetchRunningAgents(this._detectCommands());
+        if (detected === null) {
+            // Detection being unavailable (older server, transient failure) is
+            // not proof the agent is gone; refuse the write with a message that
+            // invites the retry that would succeed.
+            throw new Error(this._trans.__('Could not verify the terminal — try sending again.'));
+        }
+        const command = detected[name];
+        if (typeof command !== 'string' || !this._isAgentCommand(command)) {
+            throw new Error(this._trans.__('No agent is running in that terminal anymore.'));
+        }
+        // Deliver in the background: write straight to the session over its
+        // websocket instead of revealing its tab, so focus stays wherever the
+        // user is asking from. An open tab's live connection is reused; a
+        // closed tab gets a short-lived client connection to the running server
+        // session, without creating any widget.
+        const widget = this._findWidget(name);
+        const session = widget !== null
+            ? widget.content.session
+            : this._terminals.connectTo({ model: { name } });
+        try {
+            await waitUntilConnected(session, this._trans.__('Timed out connecting to the terminal.'));
+            // Wrapped and newline-normalised exactly like xterm's own paste
+            // handling. Writing the markers directly (rather than through an open
+            // tab's `Terminal.paste`) also sidesteps the one case paste() gets
+            // wrong: a freshly reconnected xterm whose replayed scrollback no
+            // longer holds the agent's original mode-setting escape, which makes
+            // paste() skip the wrapping the application still expects.
+            session.send({
+                type: 'stdin',
+                content: [PASTE_OPEN + prompt.replace(/\r?\n/g, '\r') + PASTE_CLOSE]
+            });
+            await new Promise(resolve => window.setTimeout(resolve, PASTE_SUBMIT_DELAY_MS));
+            if (session.isDisposed) {
+                // The tab closed during the pause; the pasted text already reached
+                // the agent's input box but Enter can no longer be delivered here.
+                throw new Error(this._trans.__('The terminal closed before the prompt was submitted.'));
+            }
+            session.send({ type: 'stdin', content: ['\r'] });
+        }
+        finally {
+            // Close a connection we opened just for this send. Disposing the
+            // client connection leaves the server session (and its agent) running.
+            if (widget === null && !session.isDisposed) {
+                session.dispose();
+            }
+        }
+    }
+    _findWidget(name) {
+        var _a;
+        return ((_a = this._tracker.find(widget => widget.content.session.name === name)) !== null && _a !== void 0 ? _a : null);
+    }
+    _onRegistryStateChanged() {
+        this._changed.emit();
+    }
+}

package/lib/terminals/index.d.ts

@@ -1,4 +1,5 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IAgentTerminals } from './tokens';
 /**
  * Adds a left-sidebar panel that lists every running terminal session.
  *
@@ -26,6 +27,11 @@ import { JupyterFrontEndPlugin } from '@jupyterlab/application';
  * consistent here as in the launcher and reuses the very same registered
  * commands and icons. When the launcher is disabled or no agents are
  * installed, the button falls back to opening a plain terminal directly.
+ *
+ * The plugin also provides {@link IAgentTerminals} — the sessions with a
+ * detection-confirmed running agent, plus a "paste a prompt into one"
+ * action — which the ask-agent popup uses to offer running agents as
+ * targets next to "new terminal".
  */
-declare const plugin: JupyterFrontEndPlugin<void>;
+declare const plugin: JupyterFrontEndPlugin<IAgentTerminals>;
 export default plugin;

package/lib/terminals/index.js

@@ -7,7 +7,9 @@ import { MenuSvg, terminalIcon } from '@jupyterlab/ui-components';
 import { IAgentSessions } from '../agentSessions';
 import { IEditorRegistry } from '../launcher/editorRegistry';
 import { agentCommandId, IAgentRegistry } from '../launcher/tokens';
+import { AgentTerminals } from './agentTerminals';
 import { SessionRegistry } from './model';
+import { IAgentTerminals } from './tokens';
 import { RunningTerminals } from './widget';
 const PLUGIN_ID = 'xtralab:terminals';
 /**
@@ -37,11 +39,17 @@ const PLUGIN_ID = 'xtralab:terminals';
  * consistent here as in the launcher and reuses the very same registered
  * commands and icons. When the launcher is disabled or no agents are
  * installed, the button falls back to opening a plain terminal directly.
+ *
+ * The plugin also provides {@link IAgentTerminals} — the sessions with a
+ * detection-confirmed running agent, plus a "paste a prompt into one"
+ * action — which the ask-agent popup uses to offer running agents as
+ * targets next to "new terminal".
  */
 const plugin = {
     id: PLUGIN_ID,
     description: 'A left-sidebar panel listing every running terminal session by its real (program-published) title, with activate/reopen, shutdown and new-terminal actions.',
     autoStart: true,
+    provides: IAgentTerminals,
     requires: [ITerminalTracker],
     optional: [
         ILayoutRestorer,
@@ -74,6 +82,34 @@ const plugin = {
             const editor = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.find(e => e.command === command || e.id === command);
             return (_a = editor === null || editor === void 0 ? void 0 : editor.icon) !== null && _a !== void 0 ? _a : terminalIcon;
         };
+        // The names the server should look for in each terminal's process tree:
+        // for every agent and editor, its configured `command` plus its canonical
+        // `id`. The id is the real CLI name (e.g. `claude`, `nvim`), so an agent
+        // whose command points at an alias — e.g. `ccm` running `claude` — is
+        // still recognised by the process it actually spawns. Read live so the
+        // list tracks settings changes; deduplicated since command and id usually
+        // coincide.
+        const detectCommands = () => {
+            var _a, _b;
+            const names = new Set();
+            for (const agent of (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents) !== null && _a !== void 0 ? _a : []) {
+                names.add(agent.command);
+                names.add(agent.id);
+            }
+            for (const editor of (_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors) !== null && _b !== void 0 ? _b : []) {
+                names.add(editor.command);
+                names.add(editor.id);
+            }
+            return Array.from(names);
+        };
+        // Whether a detected command/id belongs to a coding agent rather than an
+        // editor. Only agent sessions get a latest-activity line (editor
+        // terminals stay badge-only), and only they are offered as prompt
+        // targets through `IAgentTerminals`.
+        const isAgentCommand = (command) => {
+            var _a;
+            return (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.some(a => a.command === command || a.id === command)) !== null && _a !== void 0 ? _a : false;
+        };
         const registry = new SessionRegistry({
             serviceManager: app.serviceManager,
             tracker,
@@ -82,33 +118,8 @@ const plugin = {
             // nothing while a notebook or other widget is current instead).
             shell: app.shell,
             agentSessions,
-            // The names the server should look for in each terminal's process tree:
-            // for every agent and editor, its configured `command` plus its canonical
-            // `id`. The id is the real CLI name (e.g. `claude`, `nvim`), so an agent
-            // whose command points at an alias — e.g. `ccm` running `claude` — is
-            // still recognised by the process it actually spawns. Read live so the
-            // list tracks settings changes; deduplicated since command and id usually
-            // coincide.
-            detectCommands: () => {
-                var _a, _b;
-                const names = new Set();
-                for (const agent of (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents) !== null && _a !== void 0 ? _a : []) {
-                    names.add(agent.command);
-                    names.add(agent.id);
-                }
-                for (const editor of (_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors) !== null && _b !== void 0 ? _b : []) {
-                    names.add(editor.command);
-                    names.add(editor.id);
-                }
-                return Array.from(names);
-            },
-            // Only coding agents (not editors) get a latest-activity line, so the
-            // registry asks this whether a detected command/id is an agent before
-            // reading its output buffer — editor terminals stay badge-only.
-            isAgentCommand: (command) => {
-                var _a;
-                return (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.some(a => a.command === command || a.id === command)) !== null && _a !== void 0 ? _a : false;
-            }
+            detectCommands,
+            isAgentCommand
         });
         // Mirror the agent/editor detected in each open terminal onto its main-area
         // tab icon, so the tab matches its sidebar row. Re-running on every
@@ -116,8 +127,7 @@ const plugin = {
         // the writes neither loop nor churn.
         const syncTabIcons = () => {
             tracker.forEach(widget => {
-                var _a;
-                const session = (_a = widget.content) === null || _a === void 0 ? void 0 : _a.session;
+                const session = widget.content.session;
                 if (!session) {
                     return;
                 }
@@ -234,9 +244,19 @@ const plugin = {
                 console.error(`xtralab: failed to load ${PLUGIN_ID} settings`, reason);
             });
         }
+        return new AgentTerminals({
+            registry,
+            tracker,
+            terminals: app.serviceManager.terminals,
+            detectCommands,
+            isAgentCommand,
+            trans
+        });
     }
 };
-/** Read a boolean setting value, falling back when it is missing or invalid. */
+/**
+ * Read a boolean setting value, falling back when it is missing or invalid.
+ */
 function boolOption(value, fallback) {
     return typeof value === 'boolean' ? value : fallback;
 }

package/lib/terminals/model.d.ts

@@ -88,6 +88,16 @@ export declare class SessionRegistry implements IDisposable {
      * exits.
      */
     agentCommandFor(name: string): string | null;
+    /**
+     * The agent command server-side detection currently reports for the
+     * session, or `null` when it has not confirmed one (the session is idle,
+     * not yet covered by a poll, or detection is unavailable). Unlike
+     * {@link agentCommandFor} this never falls back to the optimistic launch
+     * tags: callers about to *write into* a session use it, and text must only
+     * ever be sent to a confirmed running agent — pasted into a shell prompt it
+     * would be executed.
+     */
+    detectedCommandFor(name: string): string | null;
     /**
      * The most recent meaningful line of output from the session's terminal, or
      * `null` when there is nothing to surface — no coding agent is running in the
@@ -177,8 +187,7 @@ export declare class SessionRegistry implements IDisposable {
      * `_initialConnection` fires). Without the filter, briefly
      * reopening a tab while an agent has yet to re-emit its xterm
      * title escape sequence would clobber the cached agent name with
-     * `Terminal 1`, which is exactly the regression we are guarding
-     * against. Live widget titles still display whatever the widget
+     * `Terminal 1`. Live widget titles still display whatever the widget
      * currently holds because `labelFor` consults the widget first;
      * the filter only affects what survives a tab close.
      */

package/lib/terminals/model.js

@@ -202,6 +202,19 @@ export class SessionRegistry {
         }
         return null;
     }
+    /**
+     * The agent command server-side detection currently reports for the
+     * session, or `null` when it has not confirmed one (the session is idle,
+     * not yet covered by a poll, or detection is unavailable). Unlike
+     * {@link agentCommandFor} this never falls back to the optimistic launch
+     * tags: callers about to *write into* a session use it, and text must only
+     * ever be sent to a confirmed running agent — pasted into a shell prompt it
+     * would be executed.
+     */
+    detectedCommandFor(name) {
+        const detected = this._detected.get(name);
+        return typeof detected === 'string' ? detected : null;
+    }
     /**
      * The most recent meaningful line of output from the session's terminal, or
      * `null` when there is nothing to surface — no coding agent is running in the
@@ -484,9 +497,8 @@ export class SessionRegistry {
         widget.disposed.disconnect(this._onWidgetDisposed, this);
     }
     _onTitleChanged(title) {
-        var _a;
         const owner = title.owner;
-        const session = (_a = owner.content) === null || _a === void 0 ? void 0 : _a.session;
+        const session = owner.content.session;
         if (!session) {
             return;
         }
@@ -501,8 +513,7 @@ export class SessionRegistry {
      * `_initialConnection` fires). Without the filter, briefly
      * reopening a tab while an agent has yet to re-emit its xterm
      * title escape sequence would clobber the cached agent name with
-     * `Terminal 1`, which is exactly the regression we are guarding
-     * against. Live widget titles still display whatever the widget
+     * `Terminal 1`. Live widget titles still display whatever the widget
      * currently holds because `labelFor` consults the widget first;
      * the filter only affects what survives a tab close.
      */
@@ -543,9 +554,13 @@ var Private;
         return true;
     }
     Private.detectedEqual = detectedEqual;
-    /** Rows above the cursor to scan when looking for the latest output. */
+    /**
+     * Rows above the cursor to scan when looking for the latest output.
+     */
     const ACTIVITY_SCAN_ROWS = 64;
-    /** Clamp for the activity string so one runaway block can't bloat a row. */
+    /**
+     * Clamp for the activity string so one runaway block can't bloat a row.
+     */
     const ACTIVITY_MAX_LENGTH = 160;
     /**
      * Horizontal box-drawing / rule characters, treated as blanks when
@@ -591,7 +606,9 @@ var Private;
         return null;
     }
     Private.readActivity = readActivity;
-    /** Sanitized text of one buffer row. */
+    /**
+     * Sanitized text of one buffer row.
+     */
     function lineText(buffer, row) {
         var _a, _b;
         return sanitizeActivity((_b = (_a = buffer.getLine(row)) === null || _a === void 0 ? void 0 : _a.translateToString(true)) !== null && _b !== void 0 ? _b : '');
@@ -620,7 +637,9 @@ var Private;
         return result;
     }
     Private.joinBlock = joinBlock;
-    /** Truncate by code point (never splitting an emoji) with an ellipsis. */
+    /**
+     * Truncate by code point (never splitting an emoji) with an ellipsis.
+     */
     function clampActivity(text) {
         const points = Array.from(text);
         return points.length > ACTIVITY_MAX_LENGTH

package/lib/terminals/tokens.d.ts

@@ -0,0 +1,66 @@
+import { Token } from '@lumino/coreutils';
+import type { ISignal } from '@lumino/signaling';
+/**
+ * One running terminal session with a confirmed coding agent inside — an
+ * entry of {@link IAgentTerminals.sessions}.
+ */
+export interface IAgentTerminalSession {
+    /**
+     * The terminal session name (terminado's, e.g. `1`).
+     */
+    name: string;
+    /**
+     * The agent identifier server-side detection reported for the session:
+     * the configured `command`, or the canonical agent `id` when the command
+     * is an alias (e.g. `ccm` spawning `claude`). Matches an `IAgent` by
+     * either field.
+     */
+    command: string;
+    /**
+     * Display label — the session's real title (the launcher's agent name, or
+     * whatever the running program published via an xterm escape sequence).
+     */
+    label: string;
+    /**
+     * The latest meaningful line of the agent's output, when its tab is open
+     * and the activity line is enabled; `null` otherwise.
+     */
+    activity: string | null;
+}
+/**
+ * Running agent terminals, and a way to send a prompt into one.
+ *
+ * `sessions` only lists sessions where server-side process detection has
+ * *confirmed* a running coding agent (editors and plain shells are excluded,
+ * as are optimistic just-launched tags): every listed session is one whose
+ * TUI can meaningfully receive pasted prompt text. `sendPrompt` re-validates
+ * against the server before writing, since pasting prose into a shell prompt
+ * would execute it.
+ */
+export interface IAgentTerminals {
+    /**
+     * Snapshot of the sessions with a detection-confirmed running agent.
+     */
+    sessions(): IAgentTerminalSession[];
+    /**
+     * Emitted whenever the {@link sessions} snapshot may have changed.
+     */
+    readonly changed: ISignal<IAgentTerminals, void>;
+    /**
+     * Paste `prompt` into the named session's terminal and press Enter.
+     *
+     * Delivery is deliberately background: the text is written straight to
+     * the session's websocket, bracketed-paste-wrapped so a multi-line prompt
+     * arrives as one block in the agent's input box, without revealing or
+     * focusing the terminal's tab — the user keeps working where they are,
+     * and the agent CLIs queue the prompt themselves when they are busy.
+     * Rejects when the session is gone or no agent is running in it anymore.
+     */
+    sendPrompt(name: string, prompt: string): Promise<void>;
+}
+/**
+ * DI token for {@link IAgentTerminals}. Provided by `xtralab:terminals`;
+ * consumed — optionally, so each side works without the other — by
+ * `xtralab:ask-agent` to offer running agent terminals as prompt targets.
+ */
+export declare const IAgentTerminals: Token<IAgentTerminals>;

package/lib/terminals/tokens.js

@@ -0,0 +1,7 @@
+import { Token } from '@lumino/coreutils';
+/**
+ * DI token for {@link IAgentTerminals}. Provided by `xtralab:terminals`;
+ * consumed — optionally, so each side works without the other — by
+ * `xtralab:ask-agent` to offer running agent terminals as prompt targets.
+ */
+export const IAgentTerminals = new Token('xtralab:IAgentTerminals', 'The running terminal sessions with a detected coding agent, and a way to send a prompt into one.');

package/lib/terminals/widget.d.ts

@@ -2,11 +2,6 @@ import { type TranslationBundle } from '@jupyterlab/translation';
 import { LabIcon, ReactWidget } from '@jupyterlab/ui-components';
 import * as React from 'react';
 import { SessionRegistry } from './model';
-/**
- * Id of the panel widget. Used for layout restoration and as the handle
- * the sidebar visibility toggle would target.
- */
-export declare const RUNNING_TERMINALS_ID = "xtralab-running-terminals";
 /**
  * Left-sidebar panel listing every running terminal session. It is the
  * sidebar counterpart of the launcher's terminal tiles: where the
@@ -52,7 +47,9 @@ export declare namespace RunningTerminals {
          * terminal widget if no tab is currently attached.
          */
         onActivate: (sessionName: string) => void;
-        /** Shut the named session down on the server. */
+        /**
+         * Shut the named session down on the server.
+         */
         onShutdown: (sessionName: string) => void;
         /**
          * Shut down every running terminal at once. The plugin is expected to

package/lib/terminals/widget.js

@@ -5,7 +5,7 @@ import * as React from 'react';
  * Id of the panel widget. Used for layout restoration and as the handle
  * the sidebar visibility toggle would target.
  */
-export const RUNNING_TERMINALS_ID = 'xtralab-running-terminals';
+const RUNNING_TERMINALS_ID = 'xtralab-running-terminals';
 /**
  * Left-sidebar panel listing every running terminal session. It is the
  * sidebar counterpart of the launcher's terminal tiles: where the

package/lib/topBar/index.js

@@ -19,7 +19,7 @@ const BUTTONS = [
         icon: leftSidebarIcon,
         caption: trans => trans.__('Toggle left sidebar'),
         rank: -1,
-        sideClass: 'xtralab-TopBarButton-left'
+        sideClass: 'jp-xtralab-TopBarButton-left'
     },
     {
         id: 'xtralab-toggle-right-sidebar',
@@ -27,7 +27,7 @@ const BUTTONS = [
         icon: rightSidebarIcon,
         caption: trans => trans.__('Toggle right sidebar'),
         rank: 1000,
-        sideClass: 'xtralab-TopBarButton-right'
+        sideClass: 'jp-xtralab-TopBarButton-right'
     }
 ];
 /**
@@ -88,7 +88,7 @@ const plugin = {
                     noFocusOnClick: true
                 });
                 button.id = spec.id;
-                button.addClass('xtralab-TopBarButton');
+                button.addClass('jp-xtralab-TopBarButton');
                 button.addClass(spec.sideClass);
                 labShell.add(button, 'top', { rank: spec.rank });
             }

package/lib/walkthrough/index.js

@@ -3,20 +3,31 @@ import { ICommandPalette } from '@jupyterlab/apputils';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { tocIcon } from '@jupyterlab/ui-components';
+import { coerceData } from '../mimeData';
 import { WalkthroughPanel } from './panel';
 const PLUGIN_ID = 'xtralab:walkthrough';
-/** Append a step to the read-only walkthrough panel. */
+/**
+ * Append a step to the read-only walkthrough panel.
+ */
 const WALKTHROUGH_COMMAND = 'xtralab:walkthrough';
 const HIGHLIGHT_LINES_COMMAND = 'xtralab:highlight-lines';
 const PANEL_ID = 'xtralab-walkthrough';
-/** Pull a `{ mimeType, data }` media object out of a JSON command argument. */
+/**
+ * Pull a `{ mimeType, data }` media object out of a JSON command argument.
+ */
 function readMedia(value) {
     if (value &&
         typeof value === 'object' &&
         !Array.isArray(value) &&
         typeof value.mimeType === 'string') {
         const media = value;
-        return { mimeType: media.mimeType, data: media.data };
+        if (media.data === undefined) {
+            return undefined;
+        }
+        return {
+            mimeType: media.mimeType,
+            data: coerceData(media.mimeType, media.data)
+        };
     }
     return undefined;
 }