@caupulican/pi-adaptative 0.80.46 → 0.80.48

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

@@ -32,6 +32,7 @@ import { hasProjectTrustInputs, ProjectTrustStore } from "../../core/trust-manag
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { readClipboardImage } from "../../utils/clipboard-image.js";
+import { parseFrontmatter } from "../../utils/frontmatter.js";
 import { parseGitUrl } from "../../utils/git.js";
 import { getCwdRelativePath, resolvePath } from "../../utils/paths.js";
 import { getPiUserAgent } from "../../utils/pi-user-agent.js";
@@ -2541,6 +2542,24 @@ export class InteractiveMode {
                 await this.handleReloadCommand();
                 return;
             }
+            if (text === "/install-resources" || text.startsWith("/install-resources ")) {
+                const args = text.slice("/install-resources".length).trim();
+                this.editor.setText("");
+                await this.handleInstallResourcesCommand(args);
+                return;
+            }
+            if (text === "/config-backup" || text.startsWith("/config-backup ")) {
+                const file = text.slice("/config-backup".length).trim() || undefined;
+                this.editor.setText("");
+                await this.handleConfigBackupCommand(file);
+                return;
+            }
+            if (text === "/config-restore" || text.startsWith("/config-restore ")) {
+                const file = text.slice("/config-restore".length).trim();
+                this.editor.setText("");
+                await this.handleConfigRestoreCommand(file);
+                return;
+            }
             if (text === "/debug") {
                 this.handleDebugCommand();
                 this.editor.setText("");
@@ -5070,40 +5089,462 @@ export class InteractiveMode {
                     this.updateAutoLearnFooter();
                     this.showStatus(`Auto Learn settings saved to ${scope}. Use /auto-learn status or /auto-learn run.`);
                 },
-                onProfileChange: (profile) => {
+                onResourcesHubAction: (action) => {
                     done();
-                    void this.applyProfile(profile);
+                    void this.handleResourcesHubAction(action);
                 },
-                onProfileCreate: () => {
+                onCancel: () => {
                     done();
-                    void this.createProfileFlow();
+                    this.ui.requestRender();
                 },
-                onProfileEdit: (profileName) => {
+            });
+            return { component: selector, focus: selector.getSettingsList() };
+        });
+    }
+    async handleResourcesHubAction(action) {
+        switch (action) {
+            case "nudge-add-source":
+                void this.addExternalResourceRootFlow().then(() => {
+                    void this.showSettingsSelector();
+                });
+                break;
+            case "active-profile":
+                void this.openActiveProfileSelector();
+                break;
+            case "manage-library":
+                void this.openLibraryManagerFlow();
+                break;
+            case "manage-profiles":
+                void this.openManageProfilesFlow();
+                break;
+            case "sources":
+                void this.openSourcesManagerFlow();
+                break;
+        }
+    }
+    async openActiveProfileSelector() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const activeNames = this.settingsManager.getActiveResourceProfileNames();
+        const options = [
+            { value: "(none)", label: "(none)", description: "No active profile (all resources enabled)" },
+            ...profiles.map((p) => ({
+                value: p.name,
+                label: p.name,
+                description: p.description || p.source,
+            })),
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Profile / Situation", "Select the active runtime profile for this session. This is session-only unless saved elsewhere.", options, activeNames[0] || "(none)", (value) => {
+                done();
+                void this.applyProfile(value === "(none)" ? "" : value).then(() => {
+                    void this.showSettingsSelector();
+                });
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openManageProfilesFlow() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const editableProfiles = profiles.map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        const options = [
+            { value: "create", label: "+ Create profile...", description: "Create a new resource profile definition." },
+        ];
+        if (this.settingsManager.getActiveResourceProfileNames().length > 0) {
+            options.push({
+                value: "persist",
+                label: "Persist active profile to...",
+                description: "Save the current active-profile selection so it survives restart.",
+            });
+        }
+        if (editableProfiles.length > 0) {
+            options.push({
+                value: "delete",
+                label: "Delete profile...",
+                description: "Remove a profile definition from where it is stored.",
+            });
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Manage Profiles", "Create, delete, or persist profile definitions.", options, "", (value) => {
+                done();
+                if (value === "create") {
+                    void this.createProfileFlow().then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+                else if (value === "persist") {
+                    void this.openPersistProfileSelector();
+                }
+                else if (value === "delete") {
+                    void this.openDeleteProfileSelector();
+                }
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openPersistProfileSelector() {
+        const scopeOptions = [
+            { value: "session", label: "session", description: "Runtime only (not written to disk)" },
+            {
+                value: "directory",
+                label: "directory",
+                description: "~/.pi/agent/resource-profiles/<hash>/settings.json",
+            },
+            { value: "project", label: "project", description: ".pi/settings.json" },
+            { value: "global", label: "global", description: "~/.pi/agent/settings.json" },
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Persist Active Profile", "Choose where to write the active-profile selection.", scopeOptions, "directory", (value) => {
+                done();
+                this.persistActiveProfile(value);
+                void this.showSettingsSelector();
+            }, () => {
+                done();
+                void this.openManageProfilesFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openDeleteProfileSelector() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const editableProfiles = registry.listProfiles().map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Delete Profile", "Pick a profile to delete.", editableProfiles, "", (value) => {
+                done();
+                this.deleteProfileFromSource(value);
+                void this.showSettingsSelector();
+            }, () => {
+                done();
+                void this.openManageProfilesFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openSourcesManagerFlow() {
+        const externalRoots = this.settingsManager.getExternalResourceRoots();
+        const trustedRoots = this.settingsManager.getTrustedResourceRoots();
+        const options = [
+            {
+                value: "add",
+                label: "+ Add external root...",
+                description: "Register a new external directory root (requires trust)",
+            },
+        ];
+        for (const r of externalRoots) {
+            const isTrusted = trustedRoots.includes(r);
+            options.push({
+                value: `remove:${r}`,
+                label: `Remove: ${r}`,
+                description: isTrusted ? "Trusted external root" : "Untrusted external root",
+            });
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Sources", "Manage external resource roots. Adding a root requires trust confirmation.", options, "", (value) => {
+                done();
+                if (value === "add") {
+                    void this.addExternalResourceRootFlow().then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+                else if (value.startsWith("remove:")) {
+                    const root = value.slice("remove:".length);
+                    void this.removeExternalResourceRootFlow(root).then(() => {
+                        void this.showSettingsSelector();
+                    });
+                }
+            }, () => {
+                done();
+                void this.showSettingsSelector();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async openLibraryManagerFlow() {
+        const activeNames = this.settingsManager.getActiveResourceProfileNames();
+        const activeName = activeNames[0];
+        if (!activeName || activeName === "(none)") {
+            this.showSelector((done) => {
+                const selector = new SelectSubmenu("No Active Profile", "Select or create a profile to manage the library.", [
+                    {
+                        value: "select",
+                        label: "Select existing profile...",
+                        description: "Choose an existing profile to activate.",
+                    },
+                    { value: "create", label: "Create new profile...", description: "Create a new profile definition." },
+                ], "select", (value) => {
                     done();
-                    void this.openProfileResourceEditor(profileName);
-                },
-                onProfilePersistActive: (scope) => {
+                    if (value === "create") {
+                        void this.createProfileAndOpenLibraryFlow();
+                    }
+                    else {
+                        void this.selectProfileAndOpenLibraryFlow();
+                    }
+                }, () => {
                     done();
-                    this.persistActiveProfile(scope);
-                },
-                onProfileDelete: (profileName) => {
+                    void this.showSettingsSelector();
+                });
+                return { component: selector, focus: selector.getSelectList() };
+            });
+            return;
+        }
+        const registry = this.settingsManager.getProfileRegistry();
+        const profile = registry.getProfile(activeName);
+        if (!profile) {
+            this.showError(`Active profile "${activeName}" not found in registry.`);
+            return;
+        }
+        const scope = this.scopeForProfileSource(profile.source);
+        void this.openLibraryEditorForProfile(profile.name, scope);
+    }
+    async createProfileAndOpenLibraryFlow() {
+        const name = await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const input = new ExtensionInputComponent("Create Profile", "Enter profile name", (value) => {
                     done();
-                    this.deleteProfileFromSource(profileName);
-                },
-                onAddExternalResourceRoot: () => {
+                    resolve(value);
+                }, () => {
                     done();
-                    void this.addExternalResourceRootFlow();
-                },
-                onRemoveExternalResourceRoot: (root) => {
+                    resolve(undefined);
+                }, { tui: this.ui });
+                return { component: input, focus: input };
+            });
+        });
+        if (name === undefined) {
+            void this.openLibraryManagerFlow();
+            return;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            this.showWarning("Profile name cannot be empty.");
+            void this.openLibraryManagerFlow();
+            return;
+        }
+        try {
+            this.settingsManager.setProfileDefinition(trimmed, {
+                name: trimmed,
+                resources: {},
+            }, "directory");
+            await this.applyProfile(trimmed);
+            void this.openLibraryEditorForProfile(trimmed, "directory");
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+            void this.openLibraryManagerFlow();
+        }
+    }
+    async selectProfileAndOpenLibraryFlow() {
+        const registry = this.settingsManager.getProfileRegistry();
+        const profiles = registry.listProfiles();
+        const editableProfiles = profiles.map((p) => ({
+            value: p.name,
+            label: p.name,
+            description: p.description || p.source,
+        }));
+        if (editableProfiles.length === 0) {
+            this.showWarning("No existing profiles to select. Please create one.");
+            void this.createProfileAndOpenLibraryFlow();
+            return;
+        }
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Select Profile", "Pick a profile to activate and edit.", editableProfiles, "", (value) => {
+                done();
+                void this.applyProfile(value).then(() => {
+                    const profile = registry.getProfile(value);
+                    const scope = this.scopeForProfileSource(profile.source);
+                    void this.openLibraryEditorForProfile(value, scope);
+                });
+            }, () => {
+                done();
+                void this.openLibraryManagerFlow();
+            });
+            return { component: selector, focus: selector.getSelectList() };
+        });
+    }
+    async getProfileResourceKinds() {
+        const loader = this.session.resourceLoader;
+        const base = (p) => p.split(/[\\/]/).pop() ?? p;
+        const allDiscoverableExtensions = await loader.getDiscoverableExtensionPaths();
+        const skills = loader.getSkills().skills;
+        const prompts = loader.getPrompts().prompts;
+        const themes = getAvailableThemesWithPaths();
+        const agents = loader.getAgentsFiles().agentsFiles;
+        const getAgentDescription = (filePath) => {
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                const { frontmatter } = parseFrontmatter(content);
+                if (typeof frontmatter.description === "string") {
+                    return frontmatter.description;
+                }
+            }
+            catch { }
+            return undefined;
+        };
+        const getExtensionDescription = (filePath) => {
+            try {
+                let dir = filePath;
+                if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()) {
+                    dir = path.dirname(filePath);
+                }
+                const pkgPath = path.join(dir, "package.json");
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                    if (typeof pkg.description === "string") {
+                        return pkg.description;
+                    }
+                }
+            }
+            catch { }
+            return undefined;
+        };
+        return [
+            {
+                kind: "tools",
+                label: "Tools",
+                items: Array.from(allToolNames).map((name) => ({ id: name })),
+            },
+            {
+                kind: "skills",
+                label: "Skills",
+                items: skills.map((s) => ({
+                    id: s.name,
+                    path: s.filePath,
+                    description: s.description,
+                })),
+            },
+            {
+                kind: "extensions",
+                label: "Extensions",
+                items: allDiscoverableExtensions.map((e) => ({
+                    id: base(e),
+                    path: e,
+                    description: getExtensionDescription(e),
+                })),
+            },
+            {
+                kind: "agents",
+                label: "Agents",
+                items: agents.map((f) => ({
+                    id: base(f.path),
+                    path: f.path,
+                    description: getAgentDescription(f.path),
+                })),
+            },
+            {
+                kind: "prompts",
+                label: "Prompts",
+                items: prompts.map((p) => ({
+                    id: p.name,
+                    path: p.filePath,
+                    description: p.description,
+                })),
+            },
+            {
+                kind: "themes",
+                label: "Themes",
+                items: themes.map((t) => ({
+                    id: t.name,
+                    path: t.path,
+                })),
+            },
+        ];
+    }
+    async openLibraryEditorForProfile(profileName, initialScope) {
+        const currentScope = initialScope;
+        const registry = this.settingsManager.getProfileRegistry();
+        const profile = registry.getProfile(profileName);
+        if (!profile) {
+            this.showError(`Profile not found: ${profileName}`);
+            return;
+        }
+        const kinds = await this.getProfileResourceKinds();
+        const originalResources = profile.resources;
+        const isActiveProfile = this.settingsManager.getActiveResourceProfileNames().includes(profile.name);
+        this.showSelector((done) => {
+            const editor = new ProfileResourceEditorComponent({
+                profileName: profile.name,
+                profileScope: currentScope,
+                initialResources: profile.resources,
+                kinds,
+                cwd: this.sessionManager.getCwd(),
+                agentDir: getAgentDir(),
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
+                onSave: (resources) => {
                     done();
-                    void this.removeExternalResourceRootFlow(root);
+                    try {
+                        this.settingsManager.setProfileDefinition(profileName, {
+                            name: profileName,
+                            description: profile.description,
+                            model: profile.model,
+                            thinking: profile.thinking,
+                            resources,
+                        }, currentScope);
+                        this.showStatus(`Saved profile "${profileName}" to ${currentScope}.`);
+                        if (isActiveProfile) {
+                            const extensionsChanged = originalResources.extensions !== resources.extensions;
+                            const otherResourcesChanged = originalResources.tools !== resources.tools ||
+                                originalResources.skills !== resources.skills ||
+                                originalResources.agents !== resources.agents ||
+                                originalResources.prompts !== resources.prompts ||
+                                originalResources.themes !== resources.themes;
+                            if (extensionsChanged && !otherResourcesChanged) {
+                                void this.reconcileExtensionsAndRefreshUI(profileName);
+                            }
+                            else {
+                                void this.refreshAfterProfileMutation(profileName);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
                 },
                 onCancel: () => {
                     done();
-                    this.ui.requestRender();
+                    void this.openLibraryManagerFlow();
+                },
+                onScopeChange: () => {
+                    done();
+                    void this.promptScopeChangeForProfile(profileName, currentScope);
                 },
             });
-            return { component: selector, focus: selector.getSettingsList() };
+            return { component: editor, focus: editor };
+        });
+    }
+    async promptScopeChangeForProfile(profileName, currentScope) {
+        const scopeOptions = [
+            { value: "session", label: "session", description: "Runtime only (not written to disk)" },
+            {
+                value: "directory",
+                label: "directory",
+                description: "~/.pi/agent/resource-profiles/<hash>/settings.json",
+            },
+            { value: "project", label: "project", description: ".pi/settings.json" },
+            { value: "global", label: "global", description: "~/.pi/agent/settings.json" },
+        ];
+        this.showSelector((done) => {
+            const selector = new SelectSubmenu("Change Profile Scope", `Select new scope for profile "${profileName}".`, scopeOptions, currentScope, (value) => {
+                done();
+                void this.openLibraryEditorForProfile(profileName, value);
+            }, () => {
+                done();
+                void this.openLibraryEditorForProfile(profileName, currentScope);
+            });
+            return { component: selector, focus: selector.getSelectList() };
         });
     }
     async handleProfilesCommand(profileName) {
@@ -5198,24 +5639,6 @@ export class InteractiveMode {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
-    async getProfileResourceKinds() {
-        const loader = this.session.resourceLoader;
-        const base = (p) => p.split(/[\\/]/).pop() ?? p;
-        // Get all discoverable extension paths (enabled and disabled) for profile filtering
-        const allDiscoverableExtensions = await loader.getDiscoverableExtensionPaths();
-        return [
-            { kind: "tools", label: "Tools", allIds: [...allToolNames] },
-            { kind: "skills", label: "Skills", allIds: loader.getSkills().skills.map((s) => s.name) },
-            {
-                kind: "extensions",
-                label: "Extensions",
-                allIds: allDiscoverableExtensions.map((e) => base(e)),
-            },
-            { kind: "agents", label: "Agents", allIds: loader.getAgentsFiles().agentsFiles.map((f) => base(f.path)) },
-            { kind: "prompts", label: "Prompts", allIds: loader.getPrompts().prompts.map((p) => p.name) },
-            { kind: "themes", label: "Themes", allIds: getAvailableThemes() },
-        ];
-    }
     /** Map where a profile currently lives to the scope we should write it back to. */
     scopeForProfileSource(source) {
         switch (source) {
@@ -5282,8 +5705,12 @@ export class InteractiveMode {
         this.showSelector((done) => {
             const editor = new ProfileResourceEditorComponent({
                 profileName,
+                profileScope: scope,
                 initialResources: {},
                 kinds,
+                cwd: this.sessionManager.getCwd(),
+                agentDir: getAgentDir(),
+                externalResourceRoots: this.settingsManager.getExternalResourceRoots(),
                 onSave: (resources) => {
                     done();
                     try {
@@ -5306,63 +5733,6 @@ export class InteractiveMode {
             return { component: editor, focus: editor };
         });
     }
-    async openProfileResourceEditor(profileName) {
-        const profile = this.settingsManager.getProfileRegistry().getProfile(profileName);
-        if (!profile) {
-            this.showError(`Profile not found: ${profileName}`);
-            return;
-        }
-        const scope = this.scopeForProfileSource(profile.source);
-        const kinds = await this.getProfileResourceKinds();
-        const isActiveProfile = this.settingsManager.getActiveResourceProfileNames().includes(profile.name);
-        const originalResources = profile.resources;
-        this.showSelector((done) => {
-            const editor = new ProfileResourceEditorComponent({
-                profileName: profile.name,
-                initialResources: profile.resources,
-                kinds,
-                onSave: (resources) => {
-                    done();
-                    try {
-                        this.settingsManager.setProfileDefinition(profile.name, {
-                            name: profile.name,
-                            description: profile.description,
-                            model: profile.model,
-                            thinking: profile.thinking,
-                            resources,
-                        }, scope);
-                        this.showStatus(`Saved profile "${profile.name}" to ${scope}.`);
-                        // For active profiles, detect if only extensions changed to avoid full reload
-                        if (isActiveProfile) {
-                            const extensionsChanged = originalResources.extensions !== resources.extensions;
-                            const otherResourcesChanged = originalResources.tools !== resources.tools ||
-                                originalResources.skills !== resources.skills ||
-                                originalResources.agents !== resources.agents ||
-                                originalResources.prompts !== resources.prompts ||
-                                originalResources.themes !== resources.themes;
-                            if (extensionsChanged && !otherResourcesChanged) {
-                                // Only extensions changed: use live reconciliation
-                                void this.reconcileExtensionsAndRefreshUI(profile.name);
-                            }
-                            else {
-                                // Other resources changed or mixed: use full reload
-                                void this.refreshAfterProfileMutation(profile.name);
-                            }
-                        }
-                        // Non-active profiles don't need refresh
-                    }
-                    catch (error) {
-                        this.showError(error instanceof Error ? error.message : String(error));
-                    }
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
-                },
-            });
-            return { component: editor, focus: editor };
-        });
-    }
     persistActiveProfile(scope) {
         const active = this.settingsManager.getActiveResourceProfileNames()[0];
         if (!active) {
@@ -6812,6 +7182,228 @@ export class InteractiveMode {
             await this.handleFatalRuntimeError("Failed to create session", error);
         }
     }
+    copyResourcesRecursively(src, dest, force, stats) {
+        if (!fs.existsSync(src))
+            return;
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        fs.mkdirSync(dest, { recursive: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                this.copyResourcesRecursively(srcPath, destPath, force, stats);
+            }
+            else if (entry.isFile()) {
+                if (fs.existsSync(destPath) && !force) {
+                    stats.skipped.push(destPath);
+                }
+                else {
+                    fs.copyFileSync(srcPath, destPath);
+                    stats.installed.push(destPath);
+                }
+            }
+        }
+    }
+    async handleInstallResourcesCommand(argsString) {
+        try {
+            const tokens = argsString.split(/\s+/).filter(Boolean);
+            let force = false;
+            let dir = "";
+            for (const t of tokens) {
+                if (t === "--force") {
+                    force = true;
+                }
+                else {
+                    dir = t;
+                }
+            }
+            if (!dir) {
+                this.showError("Usage: /install-resources <dir> [--force]");
+                return;
+            }
+            const canonical = this.settingsManager.canonicalizePath(dir);
+            if (!canonical || !fs.existsSync(canonical)) {
+                this.showError(`Source directory does not exist: ${dir}`);
+                return;
+            }
+            const trustedRoots = this.settingsManager.getTrustedResourceRoots();
+            const trusted = trustedRoots.includes(canonical);
+            if (!trusted) {
+                const trust = await new Promise((resolve) => {
+                    this.showSelector((done) => {
+                        const submenu = new SelectSubmenu("Trust external source for installation?", `The directory "${canonical}" contains extensions/resources to install. Extensions can execute arbitrary code on your machine. Do you trust it?`, [
+                            {
+                                value: "yes",
+                                label: "Yes",
+                                description: "Trust this directory and proceed with installation.",
+                            },
+                            { value: "no", label: "No", description: "Do not trust this directory. Abort." },
+                        ], "no", (value) => {
+                            done();
+                            resolve(value === "yes");
+                        }, () => {
+                            done();
+                            resolve(false);
+                        });
+                        return { component: submenu, focus: submenu.getSelectList() };
+                    });
+                });
+                if (!trust) {
+                    this.showStatus("Installation aborted. Source directory was not trusted.");
+                    return;
+                }
+                this.settingsManager.addTrustedResourceRoot(canonical, "global");
+            }
+            const subdirs = ["skills", "extensions", "prompts", "themes", "profiles"];
+            const stats = { installed: [], skipped: [] };
+            const userAgentDir = getAgentDir();
+            for (const sub of subdirs) {
+                const srcSub = path.join(canonical, sub);
+                const destSub = path.join(userAgentDir, sub);
+                if (fs.existsSync(srcSub)) {
+                    this.copyResourcesRecursively(srcSub, destSub, force, stats);
+                }
+            }
+            const installedCount = stats.installed.length;
+            const skippedCount = stats.skipped.length;
+            this.showStatus(`Installation complete: ${installedCount} resources installed, ${skippedCount} skipped.`);
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async handleConfigBackupCommand(fileArg) {
+        try {
+            const profilesDir = path.join(getAgentDir(), "profiles");
+            const profiles = {};
+            if (fs.existsSync(profilesDir)) {
+                const entries = fs.readdirSync(profilesDir);
+                for (const entry of entries) {
+                    if (entry.endsWith(".json")) {
+                        const pPath = path.join(profilesDir, entry);
+                        try {
+                            const content = fs.readFileSync(pPath, "utf-8");
+                            profiles[entry] = JSON.parse(content);
+                        }
+                        catch {
+                            // skip
+                        }
+                    }
+                }
+            }
+            const backupData = {
+                profiles,
+                settings: {
+                    resourceProfiles: this.settingsManager.settings.resourceProfiles,
+                    activeResourceProfile: this.settingsManager.settings.activeResourceProfile,
+                    externalResourceRoots: this.settingsManager.settings.externalResourceRoots,
+                    trustedResourceRoots: this.settingsManager.settings.trustedResourceRoots,
+                },
+            };
+            let targetFile = fileArg;
+            if (!targetFile) {
+                const backupsDir = path.join(getAgentDir(), "backups");
+                fs.mkdirSync(backupsDir, { recursive: true });
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                targetFile = path.join(backupsDir, `config-${timestamp}.json`);
+            }
+            else {
+                const resolved = this.settingsManager.canonicalizePath(targetFile);
+                if (resolved) {
+                    targetFile = resolved;
+                }
+            }
+            fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+            fs.writeFileSync(targetFile, JSON.stringify(backupData, null, 2), "utf-8");
+            this.showStatus(`Configuration backup saved to ${targetFile}`);
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async handleConfigRestoreCommand(fileArg) {
+        try {
+            const trimmed = fileArg.trim();
+            if (!trimmed) {
+                this.showError("Usage: /config-restore <file>");
+                return;
+            }
+            const resolved = this.settingsManager.canonicalizePath(trimmed);
+            if (!resolved || !fs.existsSync(resolved)) {
+                this.showError(`Backup file does not exist: ${trimmed}`);
+                return;
+            }
+            let bundle;
+            try {
+                const content = fs.readFileSync(resolved, "utf-8");
+                bundle = JSON.parse(content);
+            }
+            catch (error) {
+                this.showError(`Failed to parse backup file: ${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+            if (!bundle || typeof bundle !== "object") {
+                this.showError("Invalid backup file: must be a JSON object");
+                return;
+            }
+            // Confirm before clobbering
+            const confirm = await new Promise((resolve) => {
+                this.showSelector((done) => {
+                    const submenu = new SelectSubmenu("Restore configuration?", "This will overwrite existing local profiles and settings with the backup values. Do you want to continue?", [
+                        { value: "yes", label: "Yes", description: "Proceed with restoration." },
+                        { value: "no", label: "No", description: "Cancel and abort." },
+                    ], "no", (value) => {
+                        done();
+                        resolve(value === "yes");
+                    }, () => {
+                        done();
+                        resolve(false);
+                    });
+                    return { component: submenu, focus: submenu.getSelectList() };
+                });
+            });
+            if (!confirm) {
+                this.showStatus("Restore aborted.");
+                return;
+            }
+            // 1. Restore profile files (reusable-file scope)
+            if (bundle.profiles && typeof bundle.profiles === "object") {
+                const profilesDir = path.join(getAgentDir(), "profiles");
+                fs.mkdirSync(profilesDir, { recursive: true });
+                for (const [filename, content] of Object.entries(bundle.profiles)) {
+                    const targetPath = path.join(profilesDir, filename);
+                    fs.writeFileSync(targetPath, JSON.stringify(content, null, 2), "utf-8");
+                }
+            }
+            // 2. Restore settings
+            if (bundle.settings && typeof bundle.settings === "object") {
+                const bs = bundle.settings;
+                // Global profiles definitions
+                if (bs.resourceProfiles && typeof bs.resourceProfiles === "object") {
+                    for (const [name, definition] of Object.entries(bs.resourceProfiles)) {
+                        this.settingsManager.setProfileDefinition(name, definition, "global");
+                    }
+                }
+                // Active profile selection
+                if (bs.activeResourceProfile) {
+                    this.settingsManager.setActiveProfile(bs.activeResourceProfile, "global");
+                }
+                // External roots (trustedRoots are NOT restored, as per SECURITY requirement)
+                if (Array.isArray(bs.externalResourceRoots)) {
+                    this.settingsManager.setExternalResourceRoots(bs.externalResourceRoots, "global");
+                    const currentTrusted = this.settingsManager.getTrustedResourceRoots();
+                    const newTrusted = currentTrusted.filter((r) => !bs.externalResourceRoots.includes(r));
+                    this.settingsManager.setTrustedResourceRoots(newTrusted, "global");
+                }
+            }
+            this.showStatus("Configuration restored successfully.");
+            await this.handleReloadCommand();
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : String(error));
+        }
+    }
     handleDebugCommand() {
         const width = this.ui.terminal.columns;
         const height = this.ui.terminal.rows;