jupyterlab_ai_code_assistants_extension 0.6.15

package/lib/core/types.d.ts

@@ -0,0 +1,269 @@
+/** How a conversation is branched.
+ *
+ * - `native-flag` - the CLI forks in-process from a flag pair, and the new
+ *   conversation id is minted by the frontend, so the launch carries it and
+ *   the branch is watched for until its store entry materialises
+ * - `native-command` - the CLI owns the fork verb AND mints the id itself, so
+ *   the id has to be discovered by diffing the branch list after launch
+ * - `server-copy` - the CLI has no fork at all; the server copies the store
+ *   entry, answers with the new id, and the launch resumes that id
+ */
+export type ForkStrategy = 'native-flag' | 'native-command' | 'server-copy';
+/** Where a conversation's DEFAULT tab tint comes from. A user-set colour in
+ * the extension's own write-back store always wins over all three. */
+export type ColourSource = 'native' | 'derived' | 'none';
+/** Who owns a branched conversation's name.
+ *
+ * - `launch-flag` - the CLI is told the name at launch and stamps it itself
+ * - `server-side` - the server writes the name into the copied store entry
+ * - `none` - the assistant has no naming surface, so no name is asked for
+ */
+export type NamingStrategy = 'launch-flag' | 'server-side' | 'none';
+/** One launch-behaviour setting of an assistant, in that assistant's own
+ * terminology. `boolean` modes are the unsafe/skip-approval switches: they get
+ * a settings toggle (off by default) AND a context-menu launch variant.
+ * `enum` modes are settings-only choices passed through on every launch. */
+export interface ILaunchMode {
+    /** Settings key under `providers.<id>.` and launch-payload key. Uses the
+     * assistant's own terminology, never a normalised core name. */
+    id: string;
+    /** Settings title shown in the JupyterLab settings editor. */
+    title: string;
+    /** Settings description. */
+    description: string;
+    kind: 'boolean' | 'enum';
+    /** Allowed values, `enum` modes only. */
+    values?: string[];
+    /** Default value. Boolean modes default to `false` without exception. */
+    default: boolean | string;
+    /** Menu label for the launch variant this mode produces, e.g.
+     * `Skip Permissions`. Boolean modes only; absent means settings-only. */
+    menuLabel?: string;
+}
+/** Everything the core needs to know about one assistant. Pure data - no
+ * JupyterLab imports - so the settings-schema generator can read it under
+ * plain Node from the compiled barrel. */
+export interface IProviderDescriptor {
+    /** Stable id. Drives the route namespace, widget id, command namespace,
+     * settings keys and localStorage keys. */
+    id: string;
+    /** Display label, e.g. used in settings and dialogs. */
+    label: string;
+    /** Panel title and tab caption. */
+    panelTitle: string;
+    /** LabIcon name for the panel icon. Registered by the core registry. */
+    iconName: string;
+    /** SVG source for that icon. Kept as a string so the descriptor carries no
+     * JupyterLab dependency; the registry builds the LabIcon. */
+    iconSvg: string;
+    /** Binary probed on PATH server-side. Absence disables this provider only. */
+    cliBinary: string;
+    forkStrategy: ForkStrategy;
+    colourSource: ColourSource;
+    namingStrategy: NamingStrategy;
+    /** The CLI starts a brand-new conversation under an id we give it, so a
+     * fresh session is identifiable from its argv on the first poll instead of
+     * being an unknown terminal until it writes its store entry. Independent of
+     * `forkStrategy` - an assistant can accept an id for a new session and still
+     * have no fork verb at all. */
+    mintsNewSessionId: boolean;
+    launchModes: ILaunchMode[];
+    /** Sessions can be held under remote control - renders the indicator dot. */
+    hasRemoteControl: boolean;
+    /** Sessions can be owned by a live background agent - renders the chip and
+     * asks the branch endpoint for agent state. */
+    hasBgAgents: boolean;
+    /** Projects can show a live-process indicator. */
+    hasLiveProcess: boolean;
+    /** JupyterLab plugin id of the retired standalone extension this provider
+     * replaces, without the `:plugin` suffix. Present only for a provider that
+     * had one: if that plugin is still installed the core suppresses this
+     * provider's panel rather than docking a second one for the same assistant.
+     */
+    legacyPluginId?: string;
+}
+/** One project row. Fields past `extra_sessions` are capability-gated: a
+ * provider whose descriptor does not claim the capability simply omits them,
+ * and the panel renders nothing for them. */
+export interface ISession {
+    project_path: string;
+    /** The provider's own project key. Opaque to the core - it is only ever
+     * echoed back to that provider's routes. */
+    encoded_path: string;
+    session_id: string;
+    name: string;
+    name_source: 'session' | 'basename';
+    message_count: number;
+    /** Last activity, epoch milliseconds. */
+    file_mtime: number;
+    git_branch: string | null;
+    favourite: boolean;
+    /** Conversations of this project beyond the current one. */
+    extra_sessions: number;
+    summary?: string;
+    first_prompt?: string;
+    created?: string | number | null;
+    modified?: string | number | null;
+    /** The conversation's own colour, for `colourSource: 'native'` providers.
+     * One of the six colour ids, or null. */
+    colour?: string | null;
+    /** Remote control is active on this conversation (`hasRemoteControl`). */
+    remote_control?: boolean;
+    /** Short id of the live background agent holding this conversation
+     * (`hasBgAgents`), or null. Display only - the server picks the launch verb
+     * itself, where it cannot be stale. */
+    bg_id?: string | null;
+    /** A process of this assistant is running in this project
+     * (`hasLiveProcess`). */
+    live?: boolean;
+    /** Model the conversation last ran on, when the store records one. */
+    model?: string | null;
+    tokens_used?: number;
+}
+export interface ISessionsListResponse {
+    sessions: ISession[];
+}
+/** One registered provider as the server sees it. */
+export interface IProviderStatus {
+    id: string;
+    label: string;
+    /** The `providers.<id>.enabled` setting as the server last read it. */
+    enabled: boolean;
+    cli_path: string | null;
+    /** Enabled AND binary present - the only state that docks a panel. */
+    available: boolean;
+}
+export interface IStatusResponse {
+    root_dir: string;
+    providers: IProviderStatus[];
+    /** JupyterLab's own move-to-trash setting, read server-side, so dialogs say
+     * which of the two a click means rather than reciting both. */
+    delete_to_trash?: boolean;
+}
+export interface IFavouriteRequest {
+    project_path: string;
+    favourite: boolean;
+}
+export interface IFavouriteResponse {
+    favourites: string[];
+}
+/** Destructive endpoints answer with the count AND the ids that actually went,
+ * because a shortfall is not a failure: whatever was disposed of is gone, so
+ * the count has to reach the user - and only the ids named here may have their
+ * stored colour dropped, or a conversation whose deletion was refused loses its
+ * tint. */
+export interface IDisposalReport {
+    removed_count: number;
+    removed_ids: string[];
+}
+export type IRemoveResponse = IDisposalReport;
+export type ICleanupResponse = IDisposalReport;
+export type IDeleteSessionsResponse = IDisposalReport;
+export interface IBranch {
+    session_id: string;
+    file_mtime: number;
+    label: string;
+    /** Live background agent owning this branch (`hasBgAgents`), or null.
+     * Populated only when the fetch asked for it. */
+    bg_id?: string | null;
+}
+export interface IBranchesResponse {
+    current: string;
+    total: number;
+    branches: IBranch[];
+}
+export interface ISwitchResponse {
+    requested: string;
+    current: string | null;
+}
+export interface IForkRequest {
+    encoded_path: string;
+    session_id: string;
+    name?: string;
+}
+export interface IForkResponse {
+    session_id: string;
+}
+export interface ILaunchRequest {
+    project_path: string;
+    /** The project's store key. Carrying it arms the server's launch-time pin
+     * bookkeeping (a native-flag fork pins itself current, a new session clears
+     * a stale pin) and the session_not_found pre-flight - without it both are
+     * silently skipped. Send it whenever the session row is in hand. */
+    encoded_path?: string;
+    /** Conversation to open. Omit to start a brand-new one. */
+    session_id?: string;
+    /** Frontend-minted id for a brand-new conversation, when the CLI accepts
+     * one, so the terminal is identifiable from its argv on the first poll. */
+    new_session_id?: string;
+    /** Frontend-minted id for the fork (`forkStrategy: 'native-flag'`). */
+    fork_session_id?: string;
+    /** Parent conversation to fork from (`forkStrategy: 'native-command'`). */
+    fork_from?: string;
+    /** Name to stamp on the new conversation (`namingStrategy: 'launch-flag'`). */
+    name?: string;
+    /** The launch mode this action runs under, as one token in the assistant's
+     * own terminology: a boolean mode is its bare `ILaunchMode.id`, an enum mode
+     * is `<id>=<value>`. One token, not a set - the server maps a single mode to
+     * a single flag, and refuses any token the descriptor does not declare with
+     * 400 `mode_unsupported`. */
+    mode?: string;
+}
+export interface ILaunchResponse {
+    terminal_name: string;
+}
+/** What a terminal is running, as the server resolved it from `/proc`. */
+export interface ITerminalProbeResponse {
+    terminal_name: string;
+    /** The assistant's binary is the pty's process. */
+    running: boolean;
+    /** Conversation the running process holds, or null when unreadable. */
+    session_id?: string | null;
+    /** That conversation's own colour (`colourSource: 'native'`). */
+    colour?: string | null;
+    /** Working directories read from `/proc`, never from `PWD`. */
+    cwds?: string[];
+}
+/** What one provider carried over from its retired standalone extension.
+ * `keys` are settings this extension is to apply through the settings registry,
+ * which the server has no writable handle on. */
+export interface IMigratedProvider {
+    provider_id: string;
+    keys: Record<string, boolean | number | string>;
+    favourites: string[];
+}
+/** `POST migrate`. Idempotent - a second call reports an empty list. */
+export interface IMigrateResponse {
+    migrated: IMigratedProvider[];
+}
+/** The extension's own per-provider colour store: user-set tab colours keyed
+ * by conversation id. */
+export interface IColourStoreResponse {
+    colours: Record<string, string>;
+}
+/** Everything a provider hook is handed about the row it is describing. */
+export interface IHookContext {
+    session: ISession;
+    descriptor: IProviderDescriptor;
+}
+/** Optional behaviour a provider module supplies on top of its descriptor.
+ * Every hook is optional - a provider that supplies none renders the plain
+ * shared panel. */
+export interface IProviderHooks {
+    /** Label for the primary open action, when the provider distinguishes verbs
+     * (joining a live worker is not the same as resuming a dormant store entry). */
+    resumeLabel?: (session: ISession | null) => string;
+    /** Extra lines for the row tooltip. */
+    tooltipLines?: (ctx: IHookContext) => string[];
+    /** Menu label for one branch. Defaults to `<label> (<short id>) - <time>`;
+     * a provider whose titles are written in wide scripts overrides it to bound
+     * the menu by display columns rather than by code units. */
+    branchLabel?: (branch: IBranch, shortId: string) => string;
+    /** Chip appended to a branch row in the menu and the popup. */
+    branchBadge?: (branch: IBranch) => HTMLElement | null;
+}
+/** What `providers/index.ts` registers: one descriptor, optionally with hooks. */
+export interface IProviderModule {
+    descriptor: IProviderDescriptor;
+    hooks?: IProviderHooks;
+}

package/lib/core/types.js

@@ -0,0 +1,6 @@
+// Shared vocabulary of the provider core. Nothing here names an assistant:
+// every divergence between the registered providers is expressed as a
+// capability flag on the descriptor, or as an optional hook the provider
+// module supplies. Adding an assistant adds a descriptor, never a branch in
+// core code.
+export {};

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/index.js

@@ -0,0 +1,277 @@
+import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
+import { Notification } from '@jupyterlab/apputils';
+import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
+import { AssistantSessionsPanel, commandId, panelWidgetId } from './core/panel';
+import { LOG_PREFIX, ProviderRegistry } from './core/registry';
+import { requestAPI } from './core/request';
+import { PROVIDERS } from './providers';
+const PLUGIN_ID = 'jupyterlab_ai_code_assistants_extension:plugin';
+/** Sidebar rank, shared by every panel so they dock together. */
+const PANEL_RANK = 600;
+/** How often the server is re-asked which assistants are available, so a CLI
+ * installed while JupyterLab runs surfaces without a reload. */
+const STATUS_INTERVAL_MS = 60000;
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'One side panel per AI code assistant, over a shared provider registry: sessions, favourites, branching and one-click resume in a terminal.',
+    autoStart: true,
+    requires: [ILabShell],
+    optional: [
+        ILayoutRestorer,
+        ISettingRegistry,
+        ITerminalTracker,
+        IDefaultFileBrowser,
+        IColourfulTabs
+    ],
+    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs) => {
+        console.log('JupyterLab extension jupyterlab_ai_code_assistants_extension is activated!');
+        // 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);
+        const serverSettings = app.serviceManager.serverSettings;
+        const live = new Map();
+        const warnedUnknown = new Set();
+        const warnedUnavailable = new Set();
+        // Assistants whose retired standalone extension is STILL installed. This
+        // extension supersedes those three, and running both would give the user
+        // two panels and two command sets for one assistant - so the duplicate is
+        // resolved in favour of the standalone one already on screen and this
+        // provider stays dark: never started, so it never polls and never registers
+        // a command. Resolved once, at activation: a plugin cannot be installed
+        // into a running JupyterLab.
+        const suppressed = new Set();
+        for (const descriptor of registry.descriptors) {
+            if (descriptor.legacyPluginId &&
+                app.hasPlugin(`${descriptor.legacyPluginId}:plugin`)) {
+                suppressed.add(descriptor.id);
+            }
+        }
+        if (suppressed.size > 0) {
+            const packages = registry.descriptors
+                .filter(d => suppressed.has(d.id))
+                .map(d => d.legacyPluginId)
+                .join(', ');
+            console.warn(`${LOG_PREFIX} superseded extension(s) still installed: ${packages}. Their assistants are suppressed here.`);
+            // Once, not on every refresh: this runs a single time per page load.
+            Notification.warning(`AI Code Assistants: uninstall ${packages} - it is superseded by this extension, and until it goes its assistant has no panel here.`, { autoClose: false });
+        }
+        let status = null;
+        let settings = null;
+        let sidebar = 'right';
+        /** 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. */
+        const probeStatus = async () => {
+            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;
+            }
+        };
+        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; };
+        /** Settings value, or the fallback when settings are unavailable or the
+         * key is absent. An absent enable key reads as enabled - only an explicit
+         * `false` turns a provider off. */
+        const setting = (key, fallback) => {
+            if (!settings) {
+                return fallback;
+            }
+            const value = settings.get(key).composite;
+            if (value === undefined || value === null) {
+                return fallback;
+            }
+            return value;
+        };
+        /** Launch-mode values for one provider, keyed by the mode ids the
+         * assistant itself uses. */
+        const modesFor = (id) => {
+            var _a, _b;
+            const descriptor = (_a = registry.get(id)) === null || _a === void 0 ? void 0 : _a.descriptor;
+            const modes = {};
+            for (const mode of (_b = descriptor === null || descriptor === void 0 ? void 0 : descriptor.launchModes) !== null && _b !== void 0 ? _b : []) {
+                modes[mode.id] = setting(`providers.${id}.${mode.id}`, mode.default);
+            }
+            return modes;
+        };
+        /** Push the shared settings into one panel. */
+        const applySharedSettings = (panel) => {
+            // Any value other than `path` is treated as `name`, so an older saved
+            // value still maps onto a live mode.
+            const mode = setting('presentationMode', 'name') === 'path'
+                ? 'path'
+                : 'name';
+            panel.setPresentationMode(mode);
+            const limit = setting('recentLimit', 10);
+            if (typeof limit === 'number') {
+                panel.setRecentLimit(limit);
+            }
+            // Defaults ON, so only an explicit `false` turns it off.
+            panel.setColouredTabs(setting('colouredTabs', true) !== false);
+            panel.setModes(modesFor(panel.descriptor.id));
+        };
+        const dock = (panel) => {
+            // Lumino re-parents cleanly when add() is called against a different
+            // area, so the same call both docks and moves.
+            labShell.add(panel, sidebar, { rank: PANEL_RANK });
+        };
+        const start = (id) => {
+            var _a;
+            const module = registry.get(id);
+            if (!module || live.has(id)) {
+                return;
+            }
+            try {
+                const panel = new AssistantSessionsPanel({
+                    app,
+                    descriptor: module.descriptor,
+                    hooks: module.hooks,
+                    rootDir: (_a = status === null || status === void 0 ? void 0 : status.root_dir) !== null && _a !== void 0 ? _a : '',
+                    deleteToTrash: (status === null || status === void 0 ? void 0 : status.delete_to_trash) !== false,
+                    terminalTracker,
+                    fileBrowser,
+                    colourfulTabs
+                });
+                applySharedSettings(panel);
+                dock(panel);
+                // Each panel registers under its own name, so its open/closed state
+                // survives a reload independently of the others.
+                restorer === null || restorer === void 0 ? void 0 : restorer.add(panel, panelWidgetId(id));
+                const command = app.commands.addCommand(commandId(id, 'refresh'), {
+                    label: `Refresh ${module.descriptor.panelTitle}`,
+                    execute: () => panel.refresh()
+                });
+                live.set(id, { panel, command });
+            }
+            catch (err) {
+                // One provider failing to start must leave the others working.
+                console.error(`${LOG_PREFIX} provider "${id}" failed to start.`, err);
+            }
+        };
+        const stop = (id) => {
+            const entry = live.get(id);
+            if (!entry) {
+                return;
+            }
+            live.delete(id);
+            // Disposing stops the polling and clears this provider's tab tints; the
+            // terminals it launched keep running, untouched.
+            entry.command.dispose();
+            entry.panel.dispose();
+        };
+        /** Bring the docked panels in line with settings and CLI availability.
+         * Both must hold for a panel to be present. */
+        const reconcile = () => {
+            var _a, _b;
+            for (const descriptor of registry.descriptors) {
+                const id = descriptor.id;
+                if (suppressed.has(id)) {
+                    continue;
+                }
+                const enabled = setting(`providers.${id}.enabled`, true) !== false;
+                const probe = statusFor(id);
+                const available = probe ? probe.available !== false : false;
+                // Enabled but binary absent must not be a silent state: the user sees
+                // a missing panel with no clue that PATH under the Jupyter server
+                // differs from their shell. Once per id, not per reconcile.
+                if (enabled && !available && !warnedUnavailable.has(id)) {
+                    warnedUnavailable.add(id);
+                    const binary = (_b = (_a = registry.get(id)) === null || _a === void 0 ? void 0 : _a.descriptor.cliBinary) !== null && _b !== void 0 ? _b : id;
+                    console.info(`${LOG_PREFIX} "${id}" is enabled but its \`${binary}\` binary was not found on the server's PATH; panel not shown.`);
+                }
+                if (enabled && available) {
+                    if (live.has(id)) {
+                        applySharedSettings(live.get(id).panel);
+                    }
+                    else {
+                        start(id);
+                    }
+                }
+                else {
+                    stop(id);
+                }
+            }
+            // A provider still named in saved settings but no longer registered is
+            // inert. Warned once per id, not once per reconcile - this runs on every
+            // status poll, and a warning that repeats forever is noise.
+            for (const key of settings ? Object.keys(settings.composite) : []) {
+                const match = /^providers\.([^.]+)\.enabled$/.exec(key);
+                if (match && !registry.has(match[1]) && !warnedUnknown.has(match[1])) {
+                    warnedUnknown.add(match[1]);
+                    console.warn(`${LOG_PREFIX} settings name unknown assistant "${match[1]}" - ignored.`);
+                }
+            }
+        };
+        /** Carry favourites and settings over from the retired standalone
+         * extensions, once, before the first panel is docked.
+         *
+         * The server writes the favourites itself and hands back the mapped
+         * settings keys, because it has no writable handle on the settings
+         * registry. It is idempotent - a provider is marked migrated and skipped
+         * forever after - so calling it on every activation costs one request and
+         * migrates nothing the second time. A failure is a warning and nothing
+         * more: losing a carried-over favourite must never cost the user a panel.
+         *
+         * Skipped entirely while the settings registry is unavailable: the server
+         * marks a provider migrated in the same call that HANDS BACK its settings
+         * keys, so migrating with nowhere to apply them would drop a carried-over
+         * value permanently - the marker blocks every retry.
+         */
+        const migrate = async () => {
+            var _a, _b;
+            if (!settings) {
+                return;
+            }
+            try {
+                const result = await requestAPI('migrate', serverSettings, { method: 'POST', body: '{}' });
+                for (const entry of (_a = result.migrated) !== null && _a !== void 0 ? _a : []) {
+                    for (const [key, value] of Object.entries((_b = entry.keys) !== null && _b !== void 0 ? _b : {})) {
+                        await (settings === null || settings === void 0 ? void 0 : settings.set(key, value));
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`${LOG_PREFIX} migration from the retired extensions failed; nothing was carried over.`, err);
+            }
+        };
+        const applySidebar = () => {
+            const next = setting('sidebar', 'right');
+            if ((next === 'left' || next === 'right') && next !== sidebar) {
+                sidebar = next;
+                live.forEach(entry => dock(entry.panel));
+            }
+        };
+        await probeStatus();
+        if (settingRegistry) {
+            try {
+                settings = await settingRegistry.load(PLUGIN_ID);
+                sidebar =
+                    setting('sidebar', 'right') === 'left' ? 'left' : 'right';
+                settings.changed.connect(() => {
+                    applySidebar();
+                    reconcile();
+                });
+            }
+            catch (err) {
+                // Defaults apply: every provider enabled, right sidebar.
+                console.warn(`${LOG_PREFIX} failed to load settings; using defaults.`, err);
+                settings = null;
+            }
+        }
+        await migrate();
+        reconcile();
+        // Re-probe on a slow cadence so a binary installed (or removed) while
+        // JupyterLab runs takes effect on the next refresh, without a reload.
+        window.setInterval(() => {
+            void probeStatus().then(reconcile);
+        }, STATUS_INTERVAL_MS);
+        console.log(`${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`);
+    }
+};
+export default plugin;

package/lib/providers/claude.d.ts

@@ -0,0 +1,3 @@
+import { IProviderDescriptor, IProviderHooks } from '../core/types';
+export declare const descriptor: IProviderDescriptor;
+export declare const hooks: IProviderHooks;

package/lib/providers/claude.js

@@ -0,0 +1,88 @@
+// The Claude Code provider.
+//
+// Ported from `jupyterlab_claude_code_extension` v1.2.73, the architectural
+// base. Almost all of that extension's behaviour is now the shared core, and
+// what is left here is what only Claude has: the capability flags on the
+// descriptor, and the two places where "a live background agent holds this
+// conversation" changes what the user is offered.
+//
+// Nothing here touches the DOM outside its own badge element, and nothing here
+// reaches into core internals - the hooks are the whole seam.
+// Claude's own mark, drawn as a single path group so the theme's `jp-icon3`
+// fill drives it in both light and dark.
+const claudeSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
+  <g class="jp-icon3" fill="#616161">
+    <path d="m14.375 6.48.49.28v.209l-.14.489-5.937 1.397-.558-1.387zm0 0"/>
+    <path d="m12.155 2.373.683.143.182.224.173.535-.072.342-3.983 5.447L7.81 7.737l3.673-4.82z"/>
+    <path d="m8.719 1.522.419-.28.349.14.349.49-.957 5.748-.65-.441-.279-.769.49-4.33z"/>
+    <path d="m4.239 1.614.43-.55L4.95 1l.558.081.275.216 2.004 4.442.724 2.11-.848.471-3.231-5.864z"/>
+    <path d="m2.154 4.665-.14-.56.42-.488.488.07h.14l2.933 2.165.908.698 1.257.978-.698 1.187-.629-.489-.419-.419-4.05-2.863z"/>
+    <path d="M1.316 8.296 1 7.946v-.31l.316-.108 3.562.21 3.491.279-.113.695-6.66-.346z"/>
+    <path d="M3.411 11.931h-.698l-.278-.32v-.382l1.186-.838 4.82-3.068.487.833z"/>
+    <path d="m4.738 13.883-.28.07-.418-.21.07-.35 4.12-5.446.558.768-3.072 4.05z"/>
+    <path d="m8.23 14.581-.21.28-.419.14-.349-.28-.21-.42L8.09 8.646l.629.07z"/>
+    <path d="M11.791 13.045v.558l-.07.21-.279.14-.489-.066-3.356-4.996 1.331-1.014 1.117 2.025.105.733z"/>
+    <path d="m13.398 12.207.07.349-.21.279-.21-.07-1.187-.838-1.815-1.606-1.397-.978.419-1.326.698.419.42.768z"/>
+    <path d="m12.49 8.645 1.746.14.419.28.279.418v.302l-.768.327-3.911-.978-1.606-.07.419-1.466 1.117.838z"/>
+  </g>
+</svg>`;
+export const descriptor = {
+    id: 'claude',
+    label: 'Claude Code',
+    panelTitle: 'Claude Code Sessions',
+    iconName: 'jupyterlab_ai_code_assistants_extension:claude',
+    iconSvg: claudeSvgStr,
+    cliBinary: 'claude',
+    // `claude --fork-session --session-id <uuid>`: the CLI forks in-process and
+    // takes the new id from us, so the fork is known before it exists - and its
+    // store entry is written lazily, on the first turn, which is what the core's
+    // branch watcher waits for.
+    forkStrategy: 'native-flag',
+    // `/color` is Claude's own surface for a conversation's colour, recorded in
+    // its transcript, so the assistant owns the tint and the extension's
+    // write-back store stays out of it.
+    colourSource: 'native',
+    // `-n <name>` at launch: Claude stamps the name itself and re-stamps it on
+    // every turn, which is the only way a fork's name survives - a title written
+    // after the fact loses to the parent title the fork inherits.
+    namingStrategy: 'launch-flag',
+    mintsNewSessionId: true,
+    launchModes: [
+        {
+            id: 'dangerouslySkipPermissions',
+            title: 'Dangerously skip permissions',
+            description: 'When enabled, newly spawned and resumed sessions are launched with `--dangerously-skip-permissions`. Bypasses every Claude Code permission prompt - only enable in sandboxes you trust.',
+            kind: 'boolean',
+            default: false,
+            menuLabel: 'Skip Permissions'
+        }
+    ],
+    hasRemoteControl: true,
+    hasBgAgents: true,
+    // Claude records the conversation a process is on, so a terminal is
+    // identified exactly; there is no per-project "something is running here"
+    // signal to render.
+    hasLiveProcess: false,
+    // Retired standalone extension this provider replaces.
+    legacyPluginId: 'jupyterlab_claude_code_extension'
+};
+/** The `bg` chip: this conversation belongs to a live background agent, so
+ * opening it joins the running agent instead of resuming a dormant transcript.
+ * Display only - the server picks the verb at launch, where it cannot be
+ * stale. */
+function bgChip() {
+    const chip = document.createElement('span');
+    chip.className = 'jp-AiAssistantsPanel-bgBadge';
+    chip.textContent = 'bg';
+    return chip;
+}
+export const hooks = {
+    // Joining a live agent and resuming a dormant conversation are different
+    // verbs, so the item says which one this row gets before the click.
+    resumeLabel: (session) => (session === null || session === void 0 ? void 0 : session.bg_id) ? 'Attach to Background Agent' : 'Resume',
+    // In the manage-sessions popup the chip replaces the fork badge for an
+    // agent-held conversation: both are identity hints, and the one that changes
+    // what a click does is the one worth the column. Returning null elsewhere
+    // leaves the shared fork badge in place.
+    branchBadge: (branch) => (branch.bg_id ? bgChip() : null)
+};

package/lib/providers/codex.d.ts

@@ -0,0 +1,3 @@
+import { IProviderDescriptor, IProviderHooks } from '../core/types';
+export declare const descriptor: IProviderDescriptor;
+export declare const hooks: IProviderHooks;