apex-code 0.0.1-alpha.6 → 0.0.1-alpha.7

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

@@ -62,7 +62,7 @@ import { ModelSelectorComponent } from "./components/model-selector.js";
 import { formatAuthSelectorProviderType, OAuthSelectorComponent, } from "./components/oauth-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 { PERMISSION_MODE_OVERRIDE_HINTS, SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { ApexSplashHeader } from "./components/splash-header.js";
 import { BranchSummaryStatusIndicator, CompactionStatusIndicator, IdleStatus, RetryStatusIndicator, WorkingStatusIndicator, } from "./components/status-indicator.js";
@@ -212,6 +212,8 @@ export function createInteractiveTuiReference(getTui) {
 }
 export class InteractiveMode {
     runtimeHost;
+    /** Settled once the most recent /settings permission-mode write has hit disk. */
+    pendingPermissionModeWrite;
     renderer;
     ui;
     mainScreenRenderState;
@@ -1444,6 +1446,7 @@ export class InteractiveMode {
         this.applyFullscreenScrollbarSetting();
         this.footer.setSession(this.session);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.refreshFooterPermissionMode();
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.outputPad = this.settingsManager.getOutputPad();
@@ -2283,10 +2286,17 @@ export class InteractiveMode {
             text = text.trim();
             if (!text)
                 return;
+            // A mode chosen in /settings is written asynchronously. Awaiting it here
+            // keeps the store authoritative before any tool call can read it, so a
+            // switch *out* of bypassPermissions can never be raced by the next turn.
+            if (this.pendingPermissionModeWrite) {
+                await this.pendingPermissionModeWrite;
+                this.pendingPermissionModeWrite = undefined;
+            }
             // Handle commands
             if (text === "/settings") {
-                this.showSettingsSelector();
                 this.editor.setText("");
+                await this.showSettingsSelector();
                 return;
             }
             if (text === "/scoped-models") {
@@ -3593,7 +3603,52 @@ export class InteractiveMode {
         this.ui.setFocus(created.focus);
         this.ui.requestRender();
     }
-    showSettingsSelector() {
+    /**
+     * Resyncs the footer from the store. Called on every session swap, not just at
+     * startup: `applyRuntimeSettings` also repoints the cwd, and cwd selects which
+     * project-scope permission file applies, so the mode genuinely can differ
+     * between two sessions in one process. A footer left showing the old value
+     * would under-report bypassPermissions, which is the one direction that matters.
+     */
+    refreshFooterPermissionMode() {
+        void this.session.getPermissionMode().then((resolution) => {
+            this.footer.setPermissionMode(resolution?.mode ?? "default");
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Writes the mode to user scope, then reports what is actually in force. The
+     * write can be outranked by `--permission-mode` or a project file, and a
+     * settings row that silently does nothing is worse than no row at all.
+     */
+    async applyPermissionMode(mode) {
+        let resolution;
+        try {
+            const write = this.session.setPermissionMode(mode);
+            this.pendingPermissionModeWrite = write.then(() => { }, () => { });
+            resolution = await write;
+        }
+        catch (error) {
+            // Never swallow this. A permission mode the user believes they set, and
+            // did not, is the one outcome worse than the prompt they were escaping.
+            const detail = error instanceof Error ? error.message : String(error);
+            this.chatContainer.addChild(new Text(theme.fg("error", `Permission mode could not be saved: ${detail}`), 1, 0));
+            this.ui.requestRender();
+            return;
+        }
+        if (!resolution)
+            return;
+        const outranked = resolution.mode !== mode;
+        const source = PERMISSION_MODE_OVERRIDE_HINTS[resolution.origin] ?? resolution.origin;
+        const line = outranked
+            ? `Permission mode saved as ${mode}, but ${source} sets ${resolution.mode} for this session.`
+            : `Permission mode set to ${mode}.`;
+        this.chatContainer.addChild(new Text(theme.fg(outranked ? "warning" : "muted", line), 1, 0));
+        this.footer.setPermissionMode(resolution.mode);
+        this.ui.requestRender();
+    }
+    async showSettingsSelector() {
+        const permissionMode = await this.session.getPermissionMode();
         this.showSelector((done) => {
             let selector;
             selector = new SettingsSelectorComponent({
@@ -3621,6 +3676,7 @@ export class InteractiveMode {
                 showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
                 showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
                 defaultProjectTrust: this.settingsManager.getDefaultProjectTrust(),
+                permissionMode,
                 editorPaddingX: this.settingsManager.getEditorPaddingX(),
                 outputPad: this.settingsManager.getOutputPad(),
                 autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
@@ -3718,6 +3774,9 @@ export class InteractiveMode {
                 onDefaultProjectTrustChange: (defaultProjectTrust) => {
                     this.settingsManager.setDefaultProjectTrust(defaultProjectTrust);
                 },
+                onPermissionModeChange: (mode) => {
+                    void this.applyPermissionMode(mode);
+                },
                 onDoubleEscapeActionChange: (action) => {
                     this.settingsManager.setDoubleEscapeAction(action);
                 },