@caupulican/pi-adaptative 0.80.45 → 0.80.46

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

@@ -62,7 +62,7 @@ import { ProfileResourceEditorComponent, } from "./components/profile-resource-e
 import { ProfileSelectorComponent } from "./components/profile-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
-import { SettingsSelectorComponent } from "./components/settings-selector.js";
+import { SelectSubmenu, SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { ToolGroupComponent } from "./components/tool-group.js";
@@ -4926,6 +4926,8 @@ export class InteractiveMode {
                     : undefined,
                 activeProfileName: this.settingsManager.getActiveResourceProfileNames()[0],
                 profileOptions,
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
+                trustedResourceRoots: this.settingsManager.getTrustedResourceRoots(),
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -5088,6 +5090,14 @@ export class InteractiveMode {
                     done();
                     this.deleteProfileFromSource(profileName);
                 },
+                onAddExternalResourceRoot: () => {
+                    done();
+                    void this.addExternalResourceRootFlow();
+                },
+                onRemoveExternalResourceRoot: (root) => {
+                    done();
+                    void this.removeExternalResourceRootFlow(root);
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -5388,6 +5398,81 @@ export class InteractiveMode {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
+    async addExternalResourceRootFlow() {
+        const rootPath = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Add External Root", "Enter external root directory path", (value) => {
+                    done();
+                    resolve(value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (rootPath === undefined) {
+            this.ui.requestRender();
+            return;
+        }
+        const trimmed = rootPath.trim();
+        if (!trimmed) {
+            this.showError("Directory path cannot be empty");
+            return;
+        }
+        const canonical = this.settingsManager.canonicalizePath(trimmed);
+        if (!canonical) {
+            this.showError(`Invalid path: ${trimmed}`);
+            return;
+        }
+        // Prompt for trust confirmation (Yes/No)
+        const trust = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const submenu = new SelectSubmenu("Trust external source?", "This directory can load custom extensions that execute arbitrary code on your machine.", [
+                    { value: "yes", label: "Yes", description: "Trust this directory and enable loading resources." },
+                    { value: "no", label: "No", description: "Do not trust this directory. Skip loading resources." },
+                ], "no", (value) => {
+                    done();
+                    resolve(value === "yes");
+                }, () => {
+                    done();
+                    resolve(false);
+                });
+                return { component: submenu, focus: submenu.getSelectList() };
+            });
+        });
+        if (!trust) {
+            this.showStatus("Aborted. External root was not trusted.");
+            return;
+        }
+        try {
+            const currentRoots = this.settingsManager.getExternalResourceRoots();
+            if (!currentRoots.includes(canonical)) {
+                this.settingsManager.setExternalResourceRoots([...currentRoots, canonical], "global");
+            }
+            this.settingsManager.addTrustedResourceRoot(canonical, "global");
+            this.showStatus(`Added trusted external root: ${canonical}`);
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async removeExternalResourceRootFlow(root) {
+        try {
+            const currentRoots = this.settingsManager.getExternalResourceRoots();
+            const currentTrusted = this.settingsManager.getTrustedResourceRoots();
+            const newRoots = currentRoots.filter((r) => r !== root);
+            const newTrusted = currentTrusted.filter((r) => r !== root);
+            this.settingsManager.setExternalResourceRoots(newRoots, "global");
+            this.settingsManager.setTrustedResourceRoots(newTrusted, "global");
+            this.showStatus(`Removed external root: ${root}`);
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
     async handleModelCommand(searchTerm) {
         if (!searchTerm) {
             await this.showModelSelector();