xtralab 0.4.0 → 0.6.0

package/lib/git/imageDiff.js

@@ -0,0 +1,256 @@
+import * as React from 'react';
+/**
+ * xtralab's image diff, registered in place of `@jupyterlab/git:image-diff`.
+ *
+ * The git server base64-encodes binary content, so both diff hosts receive
+ * the two sides as base64 strings through the same `content()` getters used
+ * for text. This module turns those strings into `<img>` elements and
+ * offers the 2-up / swipe / onion-skin comparison modes; no diffing library
+ * is involved (`@pierre/diffs` is text-only).
+ */
+/**
+ * Raster image extensions xtralab renders as an image diff, mapped to the
+ * MIME subtype used in the `data:image/<subtype>;base64,…` URL.
+ *
+ * `.svg` is intentionally absent: it is XML text, so the `@pierre/diffs`
+ * text diff (the fallback provider) is more useful for it than an image
+ * comparison.
+ */
+const IMAGE_DATA_TYPES = {
+    '.png': 'png',
+    '.jpg': 'jpeg',
+    '.jpeg': 'jpeg',
+    '.gif': 'gif',
+    '.webp': 'webp',
+    '.bmp': 'bmp',
+    '.ico': 'x-icon'
+};
+/** The file extensions registered as the xtralab image diff provider. */
+export const IMAGE_DIFF_EXTENSIONS = Object.keys(IMAGE_DATA_TYPES);
+/**
+ * The `data:` MIME subtype for a path xtralab renders as an image, or
+ * `null` when the path is not a supported raster image.
+ */
+export function imageDataType(path) {
+    var _a;
+    const lower = path.toLowerCase();
+    const dot = lower.lastIndexOf('.');
+    if (dot < 0) {
+        return null;
+    }
+    return (_a = IMAGE_DATA_TYPES[lower.slice(dot)]) !== null && _a !== void 0 ? _a : null;
+}
+const IMAGE_DIFF_VIEW_MODE_STORAGE_KEY = 'xtralab:image-diff-view-mode';
+function readStoredImageViewMode() {
+    try {
+        const raw = window.localStorage.getItem(IMAGE_DIFF_VIEW_MODE_STORAGE_KEY);
+        if (raw === '2-up' || raw === 'swipe' || raw === 'onion') {
+            return raw;
+        }
+    }
+    catch (_a) {
+        // localStorage can throw in privacy/sandboxed contexts — 2-up is the
+        // sensible default anyway.
+    }
+    return '2-up';
+}
+function writeStoredImageViewMode(mode) {
+    try {
+        window.localStorage.setItem(IMAGE_DIFF_VIEW_MODE_STORAGE_KEY, mode);
+    }
+    catch (_a) {
+        // Best-effort.
+    }
+}
+/**
+ * Strip whitespace from a base64 payload. Python's `base64.encodebytes`
+ * (used by the git server) inserts a newline every 76 characters; most
+ * browsers tolerate that inside a `data:` URL but some are stricter, and
+ * the cleaned length also lets us size the file accurately.
+ */
+function cleanBase64(value) {
+    return value.replace(/\s+/g, '');
+}
+/** Decoded byte length of a (whitespace-free) base64 string. */
+function base64ByteLength(clean) {
+    if (clean.length === 0) {
+        return 0;
+    }
+    const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+    return Math.floor((clean.length * 3) / 4) - padding;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    const units = ['KB', 'MB', 'GB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value < 10 ? 1 : 0)} ${units[unit]}`;
+}
+function toSide(raw, fileType) {
+    const data = cleanBase64(raw);
+    const present = data.length > 0;
+    return {
+        data,
+        present,
+        uri: present ? `data:image/${fileType};base64,${data}` : null,
+        bytes: base64ByteLength(data)
+    };
+}
+/**
+ * The image comparison surface: a segmented mode selector (reusing the
+ * diff segmented-control styling so it matches the Notebook/JSON toggle)
+ * plus the selected 2-up / swipe / onion-skin view.
+ */
+export function ImageDiffView(props) {
+    const { reference, challenger, fileType } = props;
+    const ref = React.useMemo(() => toSide(reference, fileType), [reference, fileType]);
+    const chall = React.useMemo(() => toSide(challenger, fileType), [challenger, fileType]);
+    const [mode, setMode] = React.useState(() => readStoredImageViewMode());
+    const changeMode = React.useCallback((next) => {
+        setMode(next);
+        writeStoredImageViewMode(next);
+    }, []);
+    return (React.createElement("div", { className: "jp-xtralab-ImageDiff" },
+        React.createElement("div", { className: "jp-xtralab-ImageDiff-header" },
+            React.createElement("div", { className: "jp-xtralab-DiffWidget-segmented", role: "tablist", "aria-label": "Image diff view mode" }, [
+                ['2-up', '2-up'],
+                ['swipe', 'Swipe'],
+                ['onion', 'Onion Skin']
+            ].map(([value, label]) => (React.createElement("button", { key: value, type: "button", role: "tab", "aria-selected": mode === value, "data-active": mode === value, className: "jp-xtralab-DiffWidget-segmentedButton", onClick: () => changeMode(value) }, label))))),
+        React.createElement("div", { className: "jp-xtralab-ImageDiff-body" }, mode === '2-up' ? (React.createElement(TwoUp, { reference: ref, challenger: chall })) : mode === 'swipe' ? (React.createElement(Swipe, { reference: ref, challenger: chall })) : (React.createElement(OnionSkin, { reference: ref, challenger: chall })))));
+}
+function useNaturalSize() {
+    const [size, setSize] = React.useState(null);
+    const onLoad = React.useCallback((event) => {
+        setSize([
+            event.currentTarget.naturalWidth,
+            event.currentTarget.naturalHeight
+        ]);
+    }, []);
+    return [size, onLoad];
+}
+function caption(side, size, emptyLabel) {
+    if (!side.present) {
+        return emptyLabel;
+    }
+    const dims = size !== null ? `${size[0]}×${size[1]} · ` : '';
+    return `${dims}${formatBytes(side.bytes)}`;
+}
+function TwoUp({ reference, challenger }) {
+    const [refSize, onRefLoad] = useNaturalSize();
+    const [challSize, onChallLoad] = useNaturalSize();
+    return (React.createElement("div", { className: "jp-xtralab-ImageDiff-twoUp" },
+        React.createElement("figure", { className: "jp-xtralab-ImageDiff-col" },
+            React.createElement("div", { className: "jp-xtralab-ImageDiff-frame", "data-side": "reference" }, reference.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-img", src: reference.uri, alt: "Reference revision", onLoad: onRefLoad })) : (React.createElement("div", { className: "jp-xtralab-ImageDiff-empty" }, "No previous image"))),
+            React.createElement("figcaption", { className: "jp-xtralab-ImageDiff-caption" }, caption(reference, refSize, 'Added'))),
+        React.createElement("figure", { className: "jp-xtralab-ImageDiff-col" },
+            React.createElement("div", { className: "jp-xtralab-ImageDiff-frame", "data-side": "challenger" }, challenger.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-img", src: challenger.uri, alt: "Challenger revision", onLoad: onChallLoad })) : (React.createElement("div", { className: "jp-xtralab-ImageDiff-empty" }, "Deleted"))),
+            React.createElement("figcaption", { className: "jp-xtralab-ImageDiff-caption" }, caption(challenger, challSize, 'Deleted')))));
+}
+/**
+ * Range slider shared by the swipe and onion-skin views. A native
+ * `<input type="range">` (styled via CSS) keeps the bundle free of a UI
+ * component dependency.
+ */
+function RangeSlider(props) {
+    const { value, onChange, ariaLabel } = props;
+    return (React.createElement("input", { className: "jp-xtralab-ImageDiff-slider", type: "range", min: 0, max: 100, step: 1, value: value, "aria-label": ariaLabel, onChange: event => onChange(Number(event.target.value)) }));
+}
+function Swipe({ reference, challenger }) {
+    const [position, setPosition] = React.useState(50);
+    const [dragging, setDragging] = React.useState(false);
+    const frameRef = React.useRef(null);
+    const setFromClientX = React.useCallback((clientX) => {
+        const frame = frameRef.current;
+        if (frame === null) {
+            return;
+        }
+        const rect = frame.getBoundingClientRect();
+        if (rect.width <= 0) {
+            return;
+        }
+        const next = ((clientX - rect.left) / rect.width) * 100;
+        setPosition(Math.max(0, Math.min(100, next)));
+    }, []);
+    const onPointerDown = React.useCallback((event) => {
+        // Only react to the primary pointer (left click / touch / pen tip).
+        if (event.button !== 0) {
+            return;
+        }
+        event.preventDefault();
+        setDragging(true);
+        setFromClientX(event.clientX);
+    }, [setFromClientX]);
+    React.useEffect(() => {
+        if (!dragging) {
+            return;
+        }
+        const onMove = (event) => {
+            setFromClientX(event.clientX);
+        };
+        const onUp = () => {
+            setDragging(false);
+        };
+        window.addEventListener('pointermove', onMove);
+        window.addEventListener('pointerup', onUp);
+        window.addEventListener('pointercancel', onUp);
+        return () => {
+            window.removeEventListener('pointermove', onMove);
+            window.removeEventListener('pointerup', onUp);
+            window.removeEventListener('pointercancel', onUp);
+        };
+    }, [dragging, setFromClientX]);
+    const onKeyDown = React.useCallback((event) => {
+        const step = event.shiftKey ? 10 : 1;
+        let next = null;
+        switch (event.key) {
+            case 'ArrowLeft':
+                next = position - step;
+                break;
+            case 'ArrowRight':
+                next = position + step;
+                break;
+            case 'Home':
+                next = 0;
+                break;
+            case 'End':
+                next = 100;
+                break;
+        }
+        if (next === null) {
+            return;
+        }
+        event.preventDefault();
+        setPosition(Math.max(0, Math.min(100, next)));
+    }, [position]);
+    return (React.createElement("div", { className: "jp-xtralab-ImageDiff-interactive" },
+        React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeFrame", ref: frameRef, onPointerDown: onPointerDown, "data-dragging": dragging ? 'true' : undefined },
+            React.createElement("div", { className: "jp-xtralab-ImageDiff-stack" },
+                reference.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-stackImg", src: reference.uri, alt: "Reference revision", draggable: false, style: {
+                        clipPath: `inset(0 ${100 - position}% 0 0)`
+                    } })) : null,
+                challenger.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-stackImg", src: challenger.uri, alt: "Challenger revision", draggable: false, style: {
+                        clipPath: `inset(0 0 0 ${position}%)`
+                    } })) : null),
+            React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDivider", style: { left: `${position}%` }, role: "slider", "aria-label": "Swipe between reference and challenger", "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": Math.round(position), "aria-orientation": "vertical", tabIndex: 0, onKeyDown: onKeyDown },
+                React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerHandle jp-mod-top" },
+                    React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerArrow jp-mod-left" }),
+                    React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerArrow jp-mod-right" })),
+                React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerHandle jp-mod-bottom" },
+                    React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerArrow jp-mod-left" }),
+                    React.createElement("div", { className: "jp-xtralab-ImageDiff-swipeDividerArrow jp-mod-right" }))))));
+}
+function OnionSkin({ reference, challenger }) {
+    const [opacity, setOpacity] = React.useState(50);
+    return (React.createElement("div", { className: "jp-xtralab-ImageDiff-interactive" },
+        React.createElement("div", { className: "jp-xtralab-ImageDiff-stack" },
+            reference.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-stackImg", src: reference.uri, alt: "Reference revision" })) : null,
+            challenger.uri !== null ? (React.createElement("img", { className: "jp-xtralab-ImageDiff-stackImg", src: challenger.uri, alt: "Challenger revision", style: { opacity: opacity / 100 } })) : null),
+        React.createElement(RangeSlider, { value: opacity, onChange: setOpacity, ariaLabel: "Fade between reference and challenger" })));
+}

package/lib/git/index.d.ts

@@ -1,11 +1,13 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { CommandArguments, CommandIDs } from './commands';
 /**
- * The git plugin. Adds a VS Code-style "Source Control" panel to the
- * JupyterLab left sidebar and opens file diffs in the main area when the
- * user clicks an entry in the panel. Backed by the `jupyterlab_git` server
- * extension's REST API; the bundled `@jupyterlab/git` frontend is disabled
- * via `package.json`'s `jupyterlab.disabledExtensions` so the two panels do
- * not coexist.
+ * Every plugin contributed by xtralab's git integration:
+ *
+ *   1. {@link diffCommandPlugin} — the launcher's `xtralab:git:open-diff`.
+ *   2. `diffProviderPlugin` — registers the `@pierre/diffs` rendering as
+ *      jupyterlab-git's diff providers (replacing its disabled
+ *      notebook/text diff plugins).
  */
-declare const plugin: JupyterFrontEndPlugin<void>;
-export default plugin;
+declare const plugins: JupyterFrontEndPlugin<unknown>[];
+export { CommandArguments, CommandIDs };
+export default plugins;

package/lib/git/index.js

@@ -1,36 +1,29 @@
-import { ILayoutRestorer } from '@jupyterlab/application';
-import { Dialog, ICommandPalette, IThemeManager, WidgetTracker, showDialog, showErrorMessage } from '@jupyterlab/apputils';
+import { IThemeManager, WidgetTracker } from '@jupyterlab/apputils';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { CommandIDs, registerGitCommands } from './commands';
 import { PREVIEW_DIFF_WIDGET_ID, pinnedDiffWidgetId } from './diffWidget';
-import { GitPanel } from './panel';
-const GIT_PLUGIN_ID = 'xtralab:git';
+import diffProviderPlugin from './diffProvider';
+const GIT_DIFF_COMMAND_PLUGIN_ID = 'xtralab:git-diff-command';
 const GIT_DIFF_TRACKER_NAMESPACE = 'xtralab-git-diff';
 /**
- * The git plugin. Adds a VS Code-style "Source Control" panel to the
- * JupyterLab left sidebar and opens file diffs in the main area when the
- * user clicks an entry in the panel. Backed by the `jupyterlab_git` server
- * extension's REST API; the bundled `@jupyterlab/git` frontend is disabled
- * via `package.json`'s `jupyterlab.disabledExtensions` so the two panels do
- * not coexist.
+ * The launcher's git diff command plugin.
+ *
+ * The `@jupyterlab/git` frontend stays enabled (only its diff plugins are
+ * swapped — see `diffProvider.tsx`), so the upstream git panel is what the
+ * user sees in the sidebar. This plugin is the launcher dashboard's
+ * independent diff path: the `xtralab:git:open-diff` command the
+ * dashboard's "Changes" section calls, plus a tracker so reopening a diff
+ * reveals the existing tab and the preview/pin behavior keeps working.
  */
-const plugin = {
-    id: GIT_PLUGIN_ID,
-    description: 'A VS Code-style git changes panel and diff viewer powered by jupyterlab-git and @pierre/diffs.',
+const diffCommandPlugin = {
+    id: GIT_DIFF_COMMAND_PLUGIN_ID,
+    description: "The launcher dashboard's side-by-side git diff command, powered by @pierre/diffs.",
     autoStart: true,
-    optional: [
-        ILayoutRestorer,
-        IThemeManager,
-        ICommandPalette,
-        IRenderMimeRegistry
-    ],
-    activate: (app, restorer, themeManager, commandPalette, rendermime) => {
-        // Match the panel's repo path: empty string means "use the JupyterLab
-        // server's root and let git resolve the enclosing repo".
-        const repoPath = '';
-        // Track open diff widgets so the layout restorer can recreate them on
-        // reload, and so the openDiff handler can reveal an already-open diff
-        // for the same file instead of creating a duplicate.
+    optional: [IThemeManager, IRenderMimeRegistry],
+    activate: (app, themeManager, rendermime) => {
+        // Track open diff widgets so the openDiff handler can reveal an
+        // already-open diff for the same file instead of creating a duplicate
+        // (and so a promoted preview can find its pinned twin).
         const tracker = new WidgetTracker({
             namespace: GIT_DIFF_TRACKER_NAMESPACE
         });
@@ -39,36 +32,15 @@ const plugin = {
             const existing = tracker.find(widget => !widget.isDisposed && widget.id === id);
             return existing !== null && existing !== void 0 ? existing : undefined;
         };
-        const panel = new GitPanel({
-            openDiff: (change, options) => {
-                const args = { repoPath, change };
-                if ((options === null || options === void 0 ? void 0 : options.pin) === true) {
-                    args.pin = true;
-                }
-                void app.commands.execute(CommandIDs.openDiff, args);
-            },
-            confirm: async (title, body, accept) => {
-                const result = await showDialog({
-                    title,
-                    body,
-                    buttons: [Dialog.cancelButton(), Dialog.warnButton({ label: accept })]
-                });
-                return result.button.accept === true;
-            },
-            showError: showErrorMessage
-        });
-        app.shell.add(panel, 'left', { rank: 60 });
-        if (restorer !== null) {
-            restorer.add(panel, panel.id);
-        }
         registerGitCommands({
             app,
-            panel,
             themeManager,
-            commandPalette,
             contentsManager: app.serviceManager.contents,
             rendermime,
-            onChanged: () => panel.refresh(),
+            // The launcher polls git status on its own cadence and the
+            // jupyterlab-git panel auto-refreshes on the contents `fileChanged`
+            // signal a hunk-discard save emits, so no extra refresh is needed.
+            onChanged: () => undefined,
             trackDiff: widget => tracker.add(widget),
             onPinned: current => {
                 const existing = findDiff(current.content.change, true);
@@ -87,4 +59,17 @@ const plugin = {
         });
     }
 };
-export default plugin;
+/**
+ * Every plugin contributed by xtralab's git integration:
+ *
+ *   1. {@link diffCommandPlugin} — the launcher's `xtralab:git:open-diff`.
+ *   2. `diffProviderPlugin` — registers the `@pierre/diffs` rendering as
+ *      jupyterlab-git's diff providers (replacing its disabled
+ *      notebook/text diff plugins).
+ */
+const plugins = [
+    diffCommandPlugin,
+    diffProviderPlugin
+];
+export { CommandIDs };
+export default plugins;

package/lib/index.d.ts

@@ -2,9 +2,11 @@ import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 /**
  * Every plugin contributed by `xtralab`. The entry point of the
  * labextension is an array because the package bundles several independent
- * enhancements (file browser, git changes panel, …) — JupyterLab activates
+ * enhancements (file browser, git diff providers, …) — JupyterLab activates
  * each plugin individually and only the ones whose required tokens are
- * available end up running.
+ * available end up running. `gitPlugins` and `launcherPlugins` are themselves
+ * arrays (the git diff providers; the launcher plus its editor registry), so
+ * they are spread in.
  */
 declare const plugins: JupyterFrontEndPlugin<unknown>[];
 export default plugins;

package/lib/index.js

@@ -1,26 +1,32 @@
+import agentSessionsPlugin from './agentSessions';
 import fileBrowserPlugin from './fileBrowser';
 import editorBreadcrumbsPlugin from './editorBreadcrumbs';
 import editorIndentPlugin from './editorIndent';
-import gitPlugin from './git';
-import launcherPlugin from './launcher';
+import gitPlugins from './git';
+import launcherPlugins from './launcher';
 import menusPlugin from './menus';
 import sidebarPlugin from './sidebar';
-import statusBarPlugin from './statusBar';
+import terminalsPlugin from './terminals';
+import topBarPlugin from './topBar';
 /**
  * Every plugin contributed by `xtralab`. The entry point of the
  * labextension is an array because the package bundles several independent
- * enhancements (file browser, git changes panel, …) — JupyterLab activates
+ * enhancements (file browser, git diff providers, …) — JupyterLab activates
  * each plugin individually and only the ones whose required tokens are
- * available end up running.
+ * available end up running. `gitPlugins` and `launcherPlugins` are themselves
+ * arrays (the git diff providers; the launcher plus its editor registry), so
+ * they are spread in.
  */
 const plugins = [
+    agentSessionsPlugin,
     editorBreadcrumbsPlugin,
     editorIndentPlugin,
     fileBrowserPlugin,
-    gitPlugin,
-    launcherPlugin,
+    ...gitPlugins,
+    ...launcherPlugins,
     menusPlugin,
     sidebarPlugin,
-    statusBarPlugin
+    terminalsPlugin,
+    topBarPlugin
 ];
 export default plugins;

package/lib/launcher/agents.d.ts

@@ -23,7 +23,7 @@ export interface IAgent {
      * the user types one into the launcher's prompt box. The semantics:
      *
      *   - `[]` → prompt is appended as a positional argument:
-     *     `<command> 'PROMPT'`. (Used by claude, codex, gemini, vibe.)
+     *     `<command> 'PROMPT'`. (Used by claude, codex, vibe.)
      *   - `['-i']` / `['--prompt']` → the prompt is preceded by a flag:
      *     `<command> -i 'PROMPT'`. (Used by copilot, opencode.)
      *   - `undefined` → the agent does not accept an initial prompt. The

package/lib/launcher/agents.js

@@ -1,12 +1,15 @@
 import { LabIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { BUILTIN_AGENT_ICONS } from './icons';
 /**
- * Default agent cards shipped with xtralab. The list mirrors the eight
- * first-class personas in `jupyter-ai-contrib/jupyter-ai-acp-client` (which
- * is also where the icons come from), but uses the bare CLI names a user
- * would type in a terminal rather than the ACP wrapper binaries that
- * project spawns. Anything not on the user's `$PATH` is filtered out at
- * activation time, so the wider list is harmless.
+ * Default agent cards shipped with xtralab. Seven of these (Claude, Codex,
+ * Copilot, Goose, OpenCode, Kiro, Mistral Vibe) mirror first-class personas
+ * in `jupyter-ai-contrib/jupyter-ai-acp-client` (which is also where their
+ * icons come from), but use the bare CLI names a user would type in a
+ * terminal rather than the ACP wrapper binaries that project spawns.
+ * Antigravity (Google's agent-first IDE/CLI, `agy`) takes the Google slot —
+ * Gemini CLI was dropped because Google is sunsetting it for consumer
+ * accounts on 2026-06-18. Anything not on the user's `$PATH` is filtered
+ * out at activation time, so the wider list is harmless.
  */
 const DEFAULTS = [
     {
@@ -30,14 +33,20 @@ const DEFAULTS = [
         promptArgs: []
     },
     {
-        id: 'gemini',
-        label: 'Gemini',
-        caption: 'Start the Gemini CLI in a new terminal.',
-        command: 'gemini',
-        icon: BUILTIN_AGENT_ICONS.gemini,
+        id: 'antigravity',
+        label: 'Antigravity',
+        caption: 'Open Google Antigravity from a new terminal.',
+        command: 'agy',
+        icon: BUILTIN_AGENT_ICONS.antigravity,
         rank: 2,
-        requireAvailable: true,
-        promptArgs: []
+        requireAvailable: true
+        // `agy` is the Antigravity launcher binary — a VS Code-derived editor
+        // CLI that opens the Agent Manager / workspace, not a terminal REPL.
+        // Its positional args are file/folder paths, so there is no inline
+        // natural-language prompt form; like goose/kiro we omit promptArgs so a
+        // typed prompt dims the button instead of being mangled into a path.
+        // The command stays the bare binary (no `agy .`) so the server-side
+        // `shutil.which` availability check still resolves it.
     },
     {
         id: 'copilot',

package/lib/launcher/commands.d.ts

@@ -1,15 +1,14 @@
 import type { JupyterFrontEnd } from '@jupyterlab/application';
+import type { MainAreaWidget } from '@jupyterlab/apputils';
+import type { ITerminal } from '@jupyterlab/terminal';
+import type { CommandRegistry } from '@lumino/commands';
 import { type IDisposable } from '@lumino/disposable';
+import type { IAgentSessions } from '../agentSessions';
 import type { IAgent } from './agents';
 /**
  * The command id for opening the launcher.
  */
 export declare const CREATE_LAUNCHER_COMMAND = "launcher:create";
-/**
- * Build a JupyterLab command id for a given agent. Centralised so the
- * plugin and the launcher both use the same names.
- */
-export declare function agentCommandId(agentId: string): string;
 /**
  * Register a JupyterLab command per agent. Each command opens a new
  * terminal via `terminal:create-new` and feeds the agent's shell command
@@ -18,5 +17,32 @@ export declare function agentCommandId(agentId: string): string;
  * Returns a single disposable that tears down every registered command —
  * the launcher disposes the previous set before re-registering on settings
  * changes so the command palette stays in sync with the configured agents.
+ *
+ * When an `agentSessions` registry is supplied, each launch tags its terminal
+ * session with the agent's command, so the terminals panel can badge the row
+ * with the agent's logo immediately (before server-side detection confirms
+ * it).
+ */
+export declare function registerAgentCommands(app: JupyterFrontEnd, agents: IAgent[], agentSessions?: IAgentSessions | null): IDisposable;
+/**
+ * Open a fresh terminal, type `invocation` into it as if the user had, and
+ * label the tab. Shared by the per-agent launch commands and the launcher's
+ * editor tile so the fiddly "wait for the websocket, then write stdin"
+ * sequence lives in one place.
+ *
+ * `onSession`, when given, is called once with the new session's name right
+ * after the terminal is revealed. Callers use it to optimistically tag the
+ * session so the terminals panel can badge it with the agent's (or editor's)
+ * logo before server-side detection confirms the running process.
+ *
+ * Resolves with the host `MainAreaWidget` so the caller can place it — the
+ * launcher swaps it into its own tab.
  */
-export declare function registerAgentCommands(app: JupyterFrontEnd, agents: IAgent[]): IDisposable;
+export declare function launchInTerminal(commands: CommandRegistry, options: {
+    cwd?: string;
+    /** The literal command line typed into the fresh terminal. */
+    invocation: string;
+    /** Tab/title label applied once the command is sent. */
+    label: string;
+    onSession?: (sessionName: string) => void;
+}): Promise<MainAreaWidget<ITerminal.ITerminal>>;