@plmbr/notebook-intelligence 5.0.0

package/lib/api.js

@@ -0,0 +1,927 @@
+// Copyright (c) Mehmet Bektas <mbektasgh@outlook.com>
+var _a;
+import { ServerConnection } from '@jupyterlab/services';
+import { requestAPI } from './handler';
+import { URLExt } from '@jupyterlab/coreutils';
+import { Signal } from '@lumino/signaling';
+import { GITHUB_COPILOT_PROVIDER_ID, RequestDataType, BackendMessageType, AssistantMode } from './tokens';
+export var GitHubCopilotLoginStatus;
+(function (GitHubCopilotLoginStatus) {
+    GitHubCopilotLoginStatus["NotLoggedIn"] = "NOT_LOGGED_IN";
+    GitHubCopilotLoginStatus["ActivatingDevice"] = "ACTIVATING_DEVICE";
+    GitHubCopilotLoginStatus["LoggingIn"] = "LOGGING_IN";
+    GitHubCopilotLoginStatus["LoggedIn"] = "LOGGED_IN";
+})(GitHubCopilotLoginStatus || (GitHubCopilotLoginStatus = {}));
+export var ClaudeModelType;
+(function (ClaudeModelType) {
+    ClaudeModelType["None"] = "none";
+    ClaudeModelType["Inherit"] = "inherit";
+    ClaudeModelType["Default"] = "";
+})(ClaudeModelType || (ClaudeModelType = {}));
+export var ClaudeToolType;
+(function (ClaudeToolType) {
+    ClaudeToolType["ClaudeCodeTools"] = "claude-code:built-in-tools";
+    ClaudeToolType["JupyterUITools"] = "nbi:built-in-jupyter-ui-tools";
+})(ClaudeToolType || (ClaudeToolType = {}));
+function claudeMCPServerFromWire(wire) {
+    var _b, _c, _d, _e, _f;
+    return {
+        name: String((_b = wire === null || wire === void 0 ? void 0 : wire.name) !== null && _b !== void 0 ? _b : ''),
+        scope: ((_c = wire === null || wire === void 0 ? void 0 : wire.scope) !== null && _c !== void 0 ? _c : 'user'),
+        transport: String((_d = wire === null || wire === void 0 ? void 0 : wire.transport) !== null && _d !== void 0 ? _d : 'stdio'),
+        command: String((_e = wire === null || wire === void 0 ? void 0 : wire.command) !== null && _e !== void 0 ? _e : ''),
+        args: Array.isArray(wire === null || wire === void 0 ? void 0 : wire.args) ? wire.args.map(String) : [],
+        env: (wire === null || wire === void 0 ? void 0 : wire.env) && typeof wire.env === 'object'
+            ? Object.fromEntries(Object.entries(wire.env).map(([k, v]) => [String(k), String(v)]))
+            : {},
+        url: String((_f = wire === null || wire === void 0 ? void 0 : wire.url) !== null && _f !== void 0 ? _f : ''),
+        headers: (wire === null || wire === void 0 ? void 0 : wire.headers) && typeof wire.headers === 'object'
+            ? Object.fromEntries(Object.entries(wire.headers).map(([k, v]) => [String(k), String(v)]))
+            : {},
+        disabledForWorkspace: Boolean(wire === null || wire === void 0 ? void 0 : wire.disabled_for_workspace)
+    };
+}
+// Exported for direct testing of the wire-format contract. The snake_case
+// keys it consumes (managed_source, managed_ref, tracks_upstream,
+// tracking_ref, allowed_tools) are the load-bearing JSON shape between
+// the Tornado handlers and the panel; a typo here would silently corrupt
+// user state ("I toggled it on but it didn't stick").
+export function skillFromWire(wire) {
+    var _b, _c, _d, _e, _f, _g, _h;
+    return {
+        scope: wire.scope,
+        name: wire.name,
+        description: wire.description,
+        allowedTools: (_b = wire.allowed_tools) !== null && _b !== void 0 ? _b : [],
+        rootPath: wire.root_path,
+        files: (_c = wire.files) !== null && _c !== void 0 ? _c : [],
+        source: (_d = wire.source) !== null && _d !== void 0 ? _d : '',
+        managed: Boolean(wire.managed),
+        managedSource: (_e = wire.managed_source) !== null && _e !== void 0 ? _e : '',
+        managedRef: (_f = wire.managed_ref) !== null && _f !== void 0 ? _f : '',
+        tracksUpstream: Boolean(wire.tracks_upstream),
+        trackingRef: (_g = wire.tracking_ref) !== null && _g !== void 0 ? _g : '',
+        body: (_h = wire.body) !== null && _h !== void 0 ? _h : ''
+    };
+}
+function claudeModelFromWire(wire) {
+    return {
+        id: wire.id,
+        name: wire.name,
+        contextWindow: wire.context_window
+    };
+}
+// Shared frozen object returned by NBIConfig.tourOverrides when no
+// admin overrides are present. Stable identity matters for downstream
+// consumers (memoized command-palette label, useMemo deps).
+const EMPTY_TOUR_OVERRIDES = Object.freeze({});
+export class NBIConfig {
+    constructor() {
+        this.capabilities = {};
+        this.chatParticipants = [];
+        this.changed = new Signal(this);
+    }
+    get userHomeDir() {
+        return this.capabilities.user_home_dir;
+    }
+    get userConfigDir() {
+        return this.capabilities.nbi_user_config_dir;
+    }
+    get llmProviders() {
+        return this.capabilities.llm_providers;
+    }
+    get chatModels() {
+        return this.capabilities.chat_models;
+    }
+    get inlineCompletionModels() {
+        return this.capabilities.inline_completion_models;
+    }
+    get defaultChatMode() {
+        return this.capabilities.default_chat_mode;
+    }
+    get chatModel() {
+        return this.capabilities.chat_model;
+    }
+    get chatModelSupportsVision() {
+        return this.capabilities.chat_model_supports_vision === true;
+    }
+    get inlineCompletionModel() {
+        return this.capabilities.inline_completion_model;
+    }
+    get usingGitHubCopilotModel() {
+        return (this.chatModel.provider === GITHUB_COPILOT_PROVIDER_ID ||
+            this.inlineCompletionModel.provider === GITHUB_COPILOT_PROVIDER_ID);
+    }
+    get storeGitHubAccessToken() {
+        return this.capabilities.store_github_access_token === true;
+    }
+    get inlineCompletionDebouncerDelay() {
+        return Number.isInteger(this.capabilities.inline_completion_debouncer_delay)
+            ? this.capabilities.inline_completion_debouncer_delay
+            : 200;
+    }
+    get toolConfig() {
+        return this.capabilities.tool_config;
+    }
+    get mcpServers() {
+        return this.toolConfig.mcpServers;
+    }
+    getMCPServer(serverId) {
+        return this.toolConfig.mcpServers.find((server) => server.id === serverId);
+    }
+    getMCPServerPrompt(serverId, promptName) {
+        const server = this.getMCPServer(serverId);
+        if (server) {
+            return server.prompts.find((prompt) => prompt.name === promptName);
+        }
+        return null;
+    }
+    get mcpServerSettings() {
+        return this.capabilities.mcp_server_settings;
+    }
+    get claudeSettings() {
+        return this.capabilities.claude_settings;
+    }
+    get claudeModels() {
+        var _b;
+        return ((_b = this.capabilities.claude_models) !== null && _b !== void 0 ? _b : []).map(claudeModelFromWire);
+    }
+    get isInClaudeCodeMode() {
+        return this.claudeSettings.enabled === true;
+    }
+    get isClaudeCliAvailable() {
+        return this.capabilities.claude_cli_available === true;
+    }
+    get isOpenCodeCliAvailable() {
+        return this.capabilities.opencode_cli_available === true;
+    }
+    get isPiCliAvailable() {
+        return this.capabilities.pi_cli_available === true;
+    }
+    get isGitHubCopilotCliAvailable() {
+        return this.capabilities.github_copilot_cli_available === true;
+    }
+    get isCodexCliAvailable() {
+        return this.capabilities.codex_cli_available === true;
+    }
+    isCodingAgentLauncherDisabledByPolicy(launcherId) {
+        // Fail closed when the field is missing or malformed: an admin denylist
+        // must not silently disappear if capabilities haven't loaded yet or a
+        // backend regression drops the field. The companion `is*CliAvailable`
+        // getters already default to false until capabilities arrive, so on
+        // first paint the tile is hidden regardless; this just ensures the
+        // policy gate stays in effect even if a future change pre-seeds those
+        // flags.
+        const list = this.capabilities.disabled_coding_agent_launchers;
+        if (Array.isArray(list)) {
+            return list.includes(launcherId);
+        }
+        return true;
+    }
+    get chatFeedbackEnabled() {
+        return this.capabilities.chat_feedback_enabled === true;
+    }
+    // Admin-supplied tour-copy overrides, served from the capabilities
+    // response after server-side validation. Returns the raw dict; the
+    // tour module decides how to apply it. Defaults to a shared frozen
+    // empty object so callers can spread/access keys without
+    // null-checking AND the getter doesn't allocate a fresh `{}` on every
+    // read (the JupyterLab command palette polls a command's label
+    // thunk on every keystroke, so identity stability matters).
+    get tourOverrides() {
+        const v = this.capabilities.tour_overrides;
+        return v && typeof v === 'object' ? v : EMPTY_TOUR_OVERRIDES;
+    }
+    get allowGithubSkillImport() {
+        return this.capabilities.allow_github_skill_import !== false;
+    }
+    get additionalSkippedWorkspaceDirectories() {
+        const v = this.capabilities.additional_skipped_workspace_directories;
+        return Array.isArray(v) ? v : [];
+    }
+    get allowGithubPluginImport() {
+        // Default-open: missing/undefined means the org hasn't gated this, so
+        // older backends without the flag continue to allow the GitHub
+        // affordance. Mirrors `cellOutputFeatures` polarity.
+        return this.capabilities.allow_github_plugin_import !== false;
+    }
+    get cellOutputFeatures() {
+        var _b, _c, _d, _e, _f, _g, _h;
+        const v = (_b = this.capabilities.cell_output_features) !== null && _b !== void 0 ? _b : {};
+        return {
+            explain_error: {
+                enabled: ((_c = v.explain_error) === null || _c === void 0 ? void 0 : _c.enabled) !== false,
+                locked: ((_d = v.explain_error) === null || _d === void 0 ? void 0 : _d.locked) === true
+            },
+            output_followup: {
+                enabled: ((_e = v.output_followup) === null || _e === void 0 ? void 0 : _e.enabled) !== false,
+                locked: ((_f = v.output_followup) === null || _f === void 0 ? void 0 : _f.locked) === true
+            },
+            output_toolbar: {
+                enabled: ((_g = v.output_toolbar) === null || _g === void 0 ? void 0 : _g.enabled) !== false,
+                locked: ((_h = v.output_toolbar) === null || _h === void 0 ? void 0 : _h.locked) === true
+            }
+        };
+    }
+    get featurePolicies() {
+        var _b;
+        const v = (_b = this.capabilities.feature_policies) !== null && _b !== void 0 ? _b : {};
+        const names = [
+            'explain_error',
+            'output_followup',
+            'output_toolbar',
+            'claude_mode',
+            'claude_continue_conversation',
+            'claude_code_tools',
+            'claude_jupyter_ui_tools',
+            'claude_setting_source_user',
+            'claude_setting_source_project',
+            'store_github_access_token',
+            'skills_management',
+            'claude_mcp_management',
+            'claude_plugins_management',
+            'terminal_drag_drop',
+            'refresh_open_files_on_disk_change'
+        ];
+        // Policies that default *open* when the capability field is missing,
+        // covering two cases: admin-only management gates (no user toggle) where
+        // a new frontend on an older backend must keep the tab visible, and the
+        // open-files refresh watcher whose documented default is on so its
+        // first ticks before capabilities land don't silently no-op. The other
+        // policies pair with a user toggle and default closed (missing means
+        // "no user pref recorded yet, treat as off").
+        const defaultOpen = new Set([
+            'skills_management',
+            'claude_mcp_management',
+            'claude_plugins_management',
+            'refresh_open_files_on_disk_change'
+        ]);
+        const result = {};
+        for (const name of names) {
+            const entry = v[name];
+            // Strict polarity: only default-open when the entry is wholly absent
+            // (old backend). A malformed entry (string "false", null, missing
+            // `enabled` field) falls through to closed for default-closed gates
+            // and stays open only when the field is explicitly true for default-open
+            // gates — never silently land in the open bucket.
+            let enabled;
+            if (entry === undefined) {
+                enabled = defaultOpen.has(name);
+            }
+            else {
+                enabled = entry.enabled === true;
+            }
+            result[name] = {
+                enabled,
+                locked: (entry === null || entry === void 0 ? void 0 : entry.locked) === true
+            };
+        }
+        return result;
+    }
+    get settingLocks() {
+        var _b, _c;
+        const v = (_b = this.capabilities.setting_locks) !== null && _b !== void 0 ? _b : {};
+        const names = [
+            'chat_model_provider',
+            'chat_model_id',
+            'inline_completion_model_provider',
+            'inline_completion_model_id',
+            'claude_chat_model',
+            'claude_inline_completion_model',
+            'claude_api_key',
+            'claude_base_url'
+        ];
+        const result = {};
+        for (const name of names) {
+            result[name] = { locked: ((_c = v[name]) === null || _c === void 0 ? void 0 : _c.locked) === true };
+        }
+        return result;
+    }
+}
+class NBIAPI {
+    static async initialize() {
+        await this.fetchCapabilities();
+        this.updateGitHubLoginStatus();
+        NBIAPI.initializeWebsocket();
+        this._messageReceived.connect((_, msg) => {
+            msg = JSON.parse(msg);
+            if (msg.type === BackendMessageType.MCPServerStatusChange ||
+                msg.type === BackendMessageType.ClaudeCodeStatusChange) {
+                this.fetchCapabilities();
+            }
+            else if (msg.type === BackendMessageType.GitHubCopilotLoginStatusChange) {
+                // The Copilot chat-model catalogue is fetched lazily once the bearer
+                // token is minted (issue #258), so the model dropdown depends on a
+                // capabilities refresh in addition to the login-status update.
+                Promise.all([
+                    this.updateGitHubLoginStatus(),
+                    this.fetchCapabilities()
+                ]).then(() => {
+                    this.githubLoginStatusChanged.emit();
+                });
+            }
+            else if (msg.type === BackendMessageType.SkillsReloaded) {
+                this.skillsReloaded.emit();
+            }
+            else if (msg.type === BackendMessageType.ClaudeCodeHeartbeat) {
+                this.claudeCodeHeartbeat.emit();
+            }
+        });
+    }
+    static async initializeWebsocket() {
+        const serverSettings = ServerConnection.makeSettings();
+        const wsUrl = URLExt.join(serverSettings.wsUrl, 'notebook-intelligence', 'copilot');
+        this._webSocket = new serverSettings.WebSocket(wsUrl);
+        this._webSocket.onmessage = msg => {
+            this._messageReceived.emit(msg.data);
+        };
+        this._webSocket.onerror = msg => {
+            console.error(`Websocket error: ${msg}. Closing...`);
+            this._webSocket.close();
+        };
+        this._webSocket.onclose = msg => {
+            console.log(`Websocket is closed: ${msg.reason}. Reconnecting...`);
+            setTimeout(() => {
+                NBIAPI.initializeWebsocket();
+            }, 1000);
+        };
+    }
+    static getLoginStatus() {
+        return this._loginStatus;
+    }
+    static getDeviceVerificationInfo() {
+        return this._deviceVerificationInfo;
+    }
+    static getGHLoginRequired() {
+        return (this.config.usingGitHubCopilotModel &&
+            NBIAPI.getLoginStatus() === GitHubCopilotLoginStatus.NotLoggedIn);
+    }
+    static getChatEnabled() {
+        return (this.config.isInClaudeCodeMode ||
+            (this.config.chatModel.provider === GITHUB_COPILOT_PROVIDER_ID
+                ? !this.getGHLoginRequired()
+                : this.config.llmProviders.find(provider => provider.id === this.config.chatModel.provider)));
+    }
+    static getInlineCompletionEnabled() {
+        return (this.config.isInClaudeCodeMode ||
+            (this.config.inlineCompletionModel.provider === GITHUB_COPILOT_PROVIDER_ID
+                ? !this.getGHLoginRequired()
+                : this.config.llmProviders.find(provider => provider.id === this.config.inlineCompletionModel.provider)));
+    }
+    static async loginToGitHub() {
+        this._loginStatus = GitHubCopilotLoginStatus.ActivatingDevice;
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-login', { method: 'POST' })
+                .then(data => {
+                resolve({
+                    verificationURI: data.verification_uri,
+                    userCode: data.user_code
+                });
+                this.updateGitHubLoginStatus();
+            })
+                .catch(reason => {
+                console.error(`Failed to login to GitHub Copilot.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async logoutFromGitHub() {
+        this._loginStatus = GitHubCopilotLoginStatus.ActivatingDevice;
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-logout', { method: 'GET' })
+                .then(data => {
+                this.updateGitHubLoginStatus().then(() => {
+                    resolve(data);
+                });
+            })
+                .catch(reason => {
+                console.error(`Failed to logout from GitHub Copilot.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async updateGitHubLoginStatus() {
+        return new Promise((resolve, reject) => {
+            requestAPI('gh-login-status')
+                .then(response => {
+                this._loginStatus = response.status;
+                this._deviceVerificationInfo.verificationURI =
+                    response.verification_uri || '';
+                this._deviceVerificationInfo.userCode = response.user_code || '';
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to fetch GitHub Copilot login status.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async fetchCapabilities() {
+        return new Promise((resolve, reject) => {
+            requestAPI('capabilities', { method: 'GET' })
+                .then(data => {
+                const oldConfig = {
+                    capabilities: structuredClone(this.config.capabilities),
+                    chatParticipants: structuredClone(this.config.chatParticipants)
+                };
+                this.config.capabilities = structuredClone(data);
+                this.config.chatParticipants = structuredClone(data.chat_participants);
+                const newConfig = {
+                    capabilities: structuredClone(this.config.capabilities),
+                    chatParticipants: structuredClone(this.config.chatParticipants)
+                };
+                if (JSON.stringify(newConfig) !== JSON.stringify(oldConfig)) {
+                    this.configChanged.emit();
+                }
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to get extension capabilities.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async setConfig(config) {
+        requestAPI('config', {
+            method: 'POST',
+            body: JSON.stringify(config)
+        })
+            .then(data => {
+            NBIAPI.fetchCapabilities();
+        })
+            .catch(reason => {
+            console.error(`Failed to set NBI config.\n${reason}`);
+        });
+    }
+    static async updateOllamaModelList() {
+        return new Promise((resolve, reject) => {
+            requestAPI('update-provider-models', {
+                method: 'POST',
+                body: JSON.stringify({ provider: 'ollama' })
+            })
+                .then(async (data) => {
+                await NBIAPI.fetchCapabilities();
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to update ollama model list.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async updateClaudeModelList() {
+        return new Promise((resolve, reject) => {
+            requestAPI('update-provider-models', {
+                method: 'POST',
+                body: JSON.stringify({ provider: 'claude' })
+            })
+                .then(async (data) => {
+                await NBIAPI.fetchCapabilities();
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to update Claude model list.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async getMCPConfigFile() {
+        return new Promise((resolve, reject) => {
+            requestAPI('mcp-config-file', { method: 'GET' })
+                .then(async (data) => {
+                resolve(data);
+            })
+                .catch(reason => {
+                console.error(`Failed to get MCP config file.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async setMCPConfigFile(config) {
+        return new Promise((resolve, reject) => {
+            requestAPI('mcp-config-file', {
+                method: 'POST',
+                body: JSON.stringify(config)
+            })
+                .then(async (data) => {
+                resolve(data);
+            })
+                .catch(reason => {
+                console.error(`Failed to set MCP config file.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async listSkills() {
+        var _b;
+        const data = await requestAPI('skills', { method: 'GET' });
+        return ((_b = data.skills) !== null && _b !== void 0 ? _b : []).map(skillFromWire);
+    }
+    static async getSkillsContext() {
+        var _b, _c, _d, _e;
+        const data = await requestAPI('skills/context', { method: 'GET' });
+        return {
+            projectRoot: (_b = data.project_root) !== null && _b !== void 0 ? _b : '',
+            projectName: (_c = data.project_name) !== null && _c !== void 0 ? _c : '',
+            userSkillsDir: (_d = data.user_skills_dir) !== null && _d !== void 0 ? _d : '',
+            projectSkillsDir: (_e = data.project_skills_dir) !== null && _e !== void 0 ? _e : ''
+        };
+    }
+    static async readSkill(scope, name) {
+        const data = await requestAPI(`skills/${scope}/${encodeURIComponent(name)}`, { method: 'GET' });
+        return skillFromWire(data.skill);
+    }
+    static async createSkill(payload) {
+        const data = await requestAPI('skills', {
+            method: 'POST',
+            body: JSON.stringify({
+                scope: payload.scope,
+                name: payload.name,
+                description: payload.description,
+                allowed_tools: payload.allowedTools,
+                body: payload.body
+            })
+        });
+        return skillFromWire(data.skill);
+    }
+    static async updateSkill(scope, name, payload) {
+        const wire = {};
+        if (payload.description !== undefined) {
+            wire.description = payload.description;
+        }
+        if (payload.allowedTools !== undefined) {
+            wire.allowed_tools = payload.allowedTools;
+        }
+        if (payload.body !== undefined) {
+            wire.body = payload.body;
+        }
+        if (payload.tracksUpstream !== undefined) {
+            wire.tracks_upstream = payload.tracksUpstream;
+        }
+        const data = await requestAPI(`skills/${scope}/${encodeURIComponent(name)}`, {
+            method: 'PUT',
+            body: JSON.stringify(wire)
+        });
+        return skillFromWire(data.skill);
+    }
+    static async deleteSkill(scope, name) {
+        await requestAPI(`skills/${scope}/${encodeURIComponent(name)}`, {
+            method: 'DELETE'
+        });
+    }
+    static async previewSkillImport(url) {
+        var _b, _c, _d, _e, _f, _g;
+        const data = await requestAPI('skills/import/preview', {
+            method: 'POST',
+            body: JSON.stringify({ url })
+        });
+        const p = data.preview;
+        return {
+            name: p.name,
+            description: (_b = p.description) !== null && _b !== void 0 ? _b : '',
+            allowedTools: (_c = p.allowed_tools) !== null && _c !== void 0 ? _c : [],
+            body: (_d = p.body) !== null && _d !== void 0 ? _d : '',
+            files: (_e = p.files) !== null && _e !== void 0 ? _e : [],
+            sourceUrl: (_f = p.source_url) !== null && _f !== void 0 ? _f : '',
+            canonicalUrl: (_g = p.canonical_url) !== null && _g !== void 0 ? _g : '',
+            existsInUserScope: p.exists_in_user_scope === true,
+            existsInProjectScope: p.exists_in_project_scope === true
+        };
+    }
+    static async importSkill(payload) {
+        const wire = { url: payload.url, scope: payload.scope };
+        if (payload.name) {
+            wire.name = payload.name;
+        }
+        if (payload.overwrite) {
+            wire.overwrite = true;
+        }
+        if (payload.tracksUpstream) {
+            wire.tracks_upstream = true;
+        }
+        const data = await requestAPI('skills/import', {
+            method: 'POST',
+            body: JSON.stringify(wire)
+        });
+        return skillFromWire(data.skill);
+    }
+    static async syncTrackingSkill(scope, name) {
+        var _b;
+        const data = await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/sync`, { method: 'POST' });
+        return {
+            updated: Boolean(data.updated),
+            ref: (_b = data.ref) !== null && _b !== void 0 ? _b : ''
+        };
+    }
+    static async syncAllTrackingSkills() {
+        const data = await requestAPI('skills/sync-all-tracking', {
+            method: 'POST'
+        });
+        if (!Array.isArray(data === null || data === void 0 ? void 0 : data.results)) {
+            return [];
+        }
+        return data.results.map((r) => ({
+            scope: r.scope,
+            name: r.name,
+            updated: typeof r.updated === 'boolean' ? r.updated : undefined,
+            ref: typeof r.ref === 'string' ? r.ref : undefined,
+            error: typeof r.error === 'string' ? r.error : undefined
+        }));
+    }
+    static async listClaudeMCPServers() {
+        const data = await requestAPI('claude-mcp');
+        return Array.isArray(data === null || data === void 0 ? void 0 : data.servers)
+            ? data.servers.map(claudeMCPServerFromWire)
+            : [];
+    }
+    static async addClaudeMCPServer(input) {
+        const body = {
+            name: input.name,
+            scope: input.scope,
+            transport: input.transport,
+            command_or_url: input.commandOrUrl
+        };
+        if (input.args && input.args.length) {
+            body.args = input.args;
+        }
+        if (input.env && Object.keys(input.env).length) {
+            body.env = input.env;
+        }
+        if (input.headers && Object.keys(input.headers).length) {
+            body.headers = input.headers;
+        }
+        const data = await requestAPI('claude-mcp', {
+            method: 'POST',
+            body: JSON.stringify(body)
+        });
+        return claudeMCPServerFromWire(data.server);
+    }
+    static async removeClaudeMCPServer(name, scope) {
+        await requestAPI(`claude-mcp/${scope}/${encodeURIComponent(name)}`, {
+            method: 'DELETE'
+        });
+    }
+    static async setClaudeMCPServerDisabled(name, scope, disabled) {
+        const data = await requestAPI(`claude-mcp/${scope}/${encodeURIComponent(name)}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ disabled_for_workspace: disabled })
+        });
+        return claudeMCPServerFromWire(data.server);
+    }
+    static async listPlugins() {
+        const data = await requestAPI('plugins');
+        return Array.isArray(data === null || data === void 0 ? void 0 : data.plugins) ? data.plugins : [];
+    }
+    static async installPlugin(plugin, scope = 'user') {
+        await requestAPI('plugins', {
+            method: 'POST',
+            body: JSON.stringify({ plugin, scope })
+        });
+    }
+    static async uninstallPlugin(plugin, scope = 'user') {
+        await requestAPI(`plugins/${scope}/${encodeURIComponent(plugin)}`, {
+            method: 'DELETE'
+        });
+    }
+    static async setPluginEnabled(plugin, scope, enabled) {
+        await requestAPI(`plugins/${scope}/${encodeURIComponent(plugin)}`, {
+            method: 'POST',
+            body: JSON.stringify({ action: enabled ? 'enable' : 'disable' })
+        });
+    }
+    static async listPluginMarketplaces() {
+        const data = await requestAPI('plugins/marketplace');
+        return Array.isArray(data === null || data === void 0 ? void 0 : data.marketplaces)
+            ? data.marketplaces
+            : [];
+    }
+    static async listPluginMarketplacePlugins(marketplace) {
+        const data = await requestAPI(`plugins/marketplace/${encodeURIComponent(marketplace)}/plugins`);
+        return Array.isArray(data === null || data === void 0 ? void 0 : data.plugins)
+            ? data.plugins
+            : [];
+    }
+    static async addPluginMarketplace(source, scope = 'user') {
+        await requestAPI('plugins/marketplace', {
+            method: 'POST',
+            body: JSON.stringify({ source, scope })
+        });
+    }
+    static async removePluginMarketplace(name) {
+        await requestAPI(`plugins/marketplace/${encodeURIComponent(name)}`, {
+            method: 'DELETE'
+        });
+    }
+    static async updatePluginMarketplace(name) {
+        await requestAPI(`plugins/marketplace/${encodeURIComponent(name)}/update`, {
+            method: 'POST',
+            body: '{}'
+        });
+    }
+    static async reconcileManagedSkills() {
+        var _b, _c, _d, _e;
+        const data = await requestAPI('skills/reconcile', {
+            method: 'POST'
+        });
+        return {
+            added: Number((_b = data.added) !== null && _b !== void 0 ? _b : 0),
+            updated: Number((_c = data.updated) !== null && _c !== void 0 ? _c : 0),
+            removed: Number((_d = data.removed) !== null && _d !== void 0 ? _d : 0),
+            unchanged: Number((_e = data.unchanged) !== null && _e !== void 0 ? _e : 0),
+            errors: Array.isArray(data.errors) ? data.errors.map(String) : []
+        };
+    }
+    static async renameSkill(scope, name, newName) {
+        const data = await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/rename`, {
+            method: 'POST',
+            body: JSON.stringify({ new_name: newName })
+        });
+        return skillFromWire(data.skill);
+    }
+    static async readBundleFile(scope, name, path) {
+        const data = await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/files?path=${encodeURIComponent(path)}`, { method: 'GET' });
+        return data.content;
+    }
+    static async writeBundleFile(scope, name, path, content) {
+        await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/files?path=${encodeURIComponent(path)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ content })
+        });
+    }
+    static async deleteBundleFile(scope, name, path) {
+        await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/files?path=${encodeURIComponent(path)}`, { method: 'DELETE' });
+    }
+    static async renameBundleFile(scope, name, from, to) {
+        await requestAPI(`skills/${scope}/${encodeURIComponent(name)}/files/rename`, {
+            method: 'POST',
+            body: JSON.stringify({ from, to })
+        });
+    }
+    /**
+     * Subscribe to inbound websocket messages for a single request, forwarding
+     * them to `responseEmitter`. The subscription auto-disconnects when the
+     * server emits StreamEnd, preventing per-request listener accumulation.
+     */
+    static _subscribeUntilStreamEnd(messageId, responseEmitter) {
+        const handler = (_, msg) => {
+            const parsed = JSON.parse(msg);
+            if (parsed.id !== messageId) {
+                return;
+            }
+            responseEmitter.emit(parsed);
+            if (parsed.type === BackendMessageType.StreamEnd) {
+                this._messageReceived.disconnect(handler);
+            }
+        };
+        this._messageReceived.connect(handler);
+    }
+    static async chatRequest(messageId, chatId, prompt, language, currentDirectory, filename, additionalContext, chatMode, toolSelections, responseEmitter) {
+        this._subscribeUntilStreamEnd(messageId, responseEmitter);
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.ChatRequest,
+            data: {
+                chatId,
+                prompt,
+                language,
+                currentDirectory,
+                filename,
+                additionalContext,
+                chatMode,
+                toolSelections
+            }
+        }));
+    }
+    static async reloadMCPServers() {
+        return new Promise((resolve, reject) => {
+            requestAPI('reload-mcp-servers', { method: 'POST' })
+                .then(async (data) => {
+                await NBIAPI.fetchCapabilities();
+                resolve(data);
+            })
+                .catch(reason => {
+                console.error(`Failed to reload MCP servers.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async generateCode(messageId, chatId, prompt, prefix, suffix, existingCode, language, filename, responseEmitter) {
+        this._subscribeUntilStreamEnd(messageId, responseEmitter);
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.GenerateCode,
+            data: {
+                chatId,
+                prompt,
+                prefix,
+                suffix,
+                existingCode,
+                language,
+                filename
+            }
+        }));
+    }
+    static async sendChatUserInput(messageId, data) {
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.ChatUserInput,
+            data
+        }));
+    }
+    static async sendWebSocketMessage(messageId, messageType, data) {
+        this._webSocket.send(JSON.stringify({ id: messageId, type: messageType, data }));
+    }
+    static async inlineCompletionsRequest(chatId, messageId, prefix, suffix, language, filename, responseEmitter) {
+        this._subscribeUntilStreamEnd(messageId, responseEmitter);
+        this._webSocket.send(JSON.stringify({
+            id: messageId,
+            type: RequestDataType.InlineCompletionRequest,
+            data: {
+                chatId,
+                prefix,
+                suffix,
+                language,
+                filename
+            }
+        }));
+    }
+    static async uploadFile(file) {
+        const formData = new FormData();
+        formData.append('file', file, file.name);
+        return requestAPI('upload-file', {
+            method: 'POST',
+            body: formData
+        });
+    }
+    static async listClaudeSessions(scope = 'all') {
+        return new Promise((resolve, reject) => {
+            requestAPI(`claude-sessions?scope=${scope}`, {
+                method: 'GET'
+            })
+                .then(data => {
+                var _b, _c;
+                resolve({
+                    sessions: (_b = data.sessions) !== null && _b !== void 0 ? _b : [],
+                    currentCwd: (_c = data.current_cwd) !== null && _c !== void 0 ? _c : ''
+                });
+            })
+                .catch(reason => {
+                console.error(`Failed to list Claude sessions.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async resumeClaudeSession(sessionId) {
+        return new Promise((resolve, reject) => {
+            requestAPI('claude-sessions/resume', {
+                method: 'POST',
+                body: JSON.stringify({ session_id: sessionId })
+            })
+                .then(() => {
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to resume Claude session.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+    static async emitTelemetryEvent(event) {
+        const assistantMode = this.config.isInClaudeCodeMode
+            ? AssistantMode.Claude
+            : AssistantMode.Default;
+        event.data = {
+            ...(event.data || {}),
+            assistantMode
+        };
+        return new Promise((resolve, reject) => {
+            requestAPI('emit-telemetry-event', {
+                method: 'POST',
+                body: JSON.stringify(event)
+            })
+                .then(async (data) => {
+                resolve();
+            })
+                .catch(reason => {
+                console.error(`Failed to emit telemetry event.\n${reason}`);
+                reject(reason);
+            });
+        });
+    }
+}
+_a = NBIAPI;
+NBIAPI._loginStatus = GitHubCopilotLoginStatus.NotLoggedIn;
+NBIAPI._deviceVerificationInfo = {
+    verificationURI: '',
+    userCode: ''
+};
+NBIAPI._messageReceived = new Signal(_a);
+NBIAPI.config = new NBIConfig();
+NBIAPI.configChanged = _a.config.changed;
+NBIAPI.githubLoginStatusChanged = new Signal(_a);
+NBIAPI.skillsReloaded = new Signal(_a);
+// Emits each time the Claude agent sends its 20s keepalive (#252 follow-up).
+// The chat sidebar uses it to drive the "Generating" indicator's pulse
+// and to swap to a "server may be slow" copy when the gap stretches.
+NBIAPI.claudeCodeHeartbeat = new Signal(_a);
+export { NBIAPI };