@elyracode/coding-agent 0.9.1 → 0.9.2

package/dist/modes/interactive/interactive-mode.js

@@ -3031,8 +3031,8 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     showPackageUpdateNotification(packages) {
-        const action = theme.fg("accent", `${APP_NAME} update`);
-        const updateInstruction = theme.fg("muted", "Package updates are available. Run ") + action;
+        const action = theme.fg("accent", "/update");
+        const updateInstruction = theme.fg("muted", "Extension updates are available. Type ") + action;
         const packageLines = packages.map((pkg) => `- ${pkg}`).join("\n");
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
@@ -3528,71 +3528,114 @@ export class InteractiveMode {
         }
     }
     async handleInAppUpdate() {
-        // If no update detected yet, check now
+        if (process.env.ELYRA_OFFLINE) {
+            this.showStatus("Updates are disabled in offline mode.");
+            return;
+        }
+        this.chatContainer.addChild(new Spacer(1));
+        const statusText = new Text(theme.fg("dim", "Checking for updates..."), 1, 0);
+        this.chatContainer.addChild(statusText);
+        this.ui.requestRender();
+        // Check for an Elyra version update (populates this._availableUpdate).
         if (!this._availableUpdate) {
             await this.checkForVersionUpdate();
         }
-        if (!this._availableUpdate) {
-            this.showStatus(`Already on latest version (${this.version})`);
+        const elyraUpdate = this._availableUpdate;
+        // Check for installed-extension updates.
+        const packageManager = new DefaultPackageManager({
+            cwd: this.sessionManager.getCwd(),
+            agentDir: getAgentDir(),
+            settingsManager: this.settingsManager,
+        });
+        let extensionUpdates = [];
+        try {
+            extensionUpdates = await packageManager.checkForAvailableUpdates();
+        }
+        catch {
+            // Best-effort: a failed extension check shouldn't block an Elyra update.
+        }
+        if (!elyraUpdate && extensionUpdates.length === 0) {
+            statusText.setText(theme.fg("dim", `Already up to date (Elyra ${this.version}, all extensions current)`));
+            this.ui.requestRender();
             return;
         }
-        const { latest, current } = this._availableUpdate;
-        // Get the self-update command for this installation
-        const settingsManager = this.settingsManager;
-        const npmCommand = settingsManager.getGlobalSettings().npmCommand;
-        const selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, npmCommand);
-        if (!selfUpdateCommand) {
-            this.showError(`Cannot self-update this installation. Run manually:\n  ${theme.fg("accent", `npm install -g ${PACKAGE_NAME}`)}`);
+        // If an Elyra update is available, make sure we can actually self-update.
+        let selfUpdateCommand;
+        if (elyraUpdate) {
+            const npmCommand = this.settingsManager.getGlobalSettings().npmCommand;
+            selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, npmCommand);
+            if (!selfUpdateCommand) {
+                statusText.setText(theme.fg("error", `Cannot self-update this installation. Update Elyra manually: npm install -g ${PACKAGE_NAME}`));
+                this.ui.requestRender();
+                // We can still update extensions below.
+            }
+        }
+        // Nothing actionable: Elyra can't self-update and there are no extension updates.
+        if (extensionUpdates.length === 0 && !(elyraUpdate && selfUpdateCommand)) {
             return;
         }
-        // Show progress
-        this.chatContainer.addChild(new Spacer(1));
-        const updateText = new Text(theme.fg("accent", `Updating ${current} \u2192 ${latest}...`), 1, 0);
-        this.chatContainer.addChild(updateText);
+        // Announce what is being updated.
+        const parts = [];
+        if (elyraUpdate && selfUpdateCommand)
+            parts.push(`Elyra ${elyraUpdate.current} \u2192 ${elyraUpdate.latest}`);
+        if (extensionUpdates.length > 0) {
+            parts.push(`${extensionUpdates.length} extension${extensionUpdates.length === 1 ? "" : "s"}`);
+        }
+        statusText.setText(theme.fg("accent", `Updating ${parts.join(" and ")}...`));
         this.ui.requestRender();
-        try {
-            // Run each step of the update command
-            for (const step of selfUpdateCommand.steps ?? [selfUpdateCommand]) {
-                await new Promise((resolve, reject) => {
-                    const child = spawn(step.command, step.args, {
-                        stdio: ["ignore", "pipe", "pipe"],
-                        shell: process.platform === "win32",
-                    });
-                    let stderr = "";
-                    child.stderr?.on("data", (data) => {
-                        stderr += data.toString();
-                    });
-                    child.on("close", (code) => {
-                        if (code === 0)
-                            resolve();
-                        else
-                            reject(new Error(stderr.trim() || `Exit code ${code}`));
-                    });
-                    child.on("error", reject);
-                });
+        // 1. Update extensions while Elyra is still running.
+        if (extensionUpdates.length > 0) {
+            try {
+                await packageManager.update();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.showError(`Extension update failed: ${msg}`);
             }
-            // Success — show message and restart
-            updateText.setText(theme.fg("accent", `Updated to ${latest}. Restarting...`));
-            this.ui.requestRender();
-            // Brief pause so the user sees the message
-            await new Promise((r) => setTimeout(r, 500));
-            // Restart: stop TUI, then exec the same command
-            this.stop();
-            await this.runtimeHost.dispose();
-            // Re-exec elyra with the same arguments
-            const args = process.argv.slice(1);
-            const child = spawn(process.argv[0], args, {
-                stdio: "inherit",
-                shell: false,
-            });
-            child.on("close", (code) => {
-                process.exit(code ?? 0);
-            });
         }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.showError(`Update failed: ${msg}\n\nRun manually: ${selfUpdateCommand.display}`);
+        // 2. Self-update Elyra if a newer version is available and updatable.
+        if (elyraUpdate && selfUpdateCommand) {
+            try {
+                for (const step of selfUpdateCommand.steps ?? [selfUpdateCommand]) {
+                    await new Promise((resolve, reject) => {
+                        const child = spawn(step.command, step.args, {
+                            stdio: ["ignore", "pipe", "pipe"],
+                            shell: process.platform === "win32",
+                        });
+                        let stderr = "";
+                        child.stderr?.on("data", (data) => {
+                            stderr += data.toString();
+                        });
+                        child.on("close", (code) => {
+                            if (code === 0)
+                                resolve();
+                            else
+                                reject(new Error(stderr.trim() || `Exit code ${code}`));
+                        });
+                        child.on("error", reject);
+                    });
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.showError(`Elyra update failed: ${msg}\n\nRun manually: ${selfUpdateCommand.display}`);
+                return;
+            }
         }
+        // 3. Restart so the new Elyra and/or updated extensions load fresh.
+        statusText.setText(theme.fg("accent", "Updated. Restarting..."));
+        this.ui.requestRender();
+        await new Promise((r) => setTimeout(r, 500));
+        this.stop();
+        await this.runtimeHost.dispose();
+        const args = process.argv.slice(1);
+        const child = spawn(process.argv[0], args, {
+            stdio: "inherit",
+            shell: false,
+        });
+        child.on("close", (code) => {
+            process.exit(code ?? 0);
+        });
     }
     handleGoalCommand(args) {
         // No args = show or clear goal