@dexto/tui 1.13.5 → 1.14.0

package/dist/hooks/useCLIState.test.js

@@ -0,0 +1,582 @@
+import { createElement, createRef, Fragment } from "react";
+import { PassThrough } from "node:stream";
+import { render, Static, Text } from "ink";
+import { describe, expect, it, vi } from "vitest";
+import { useCLIState } from "./useCLIState.js";
+import { KeypressProvider } from "../contexts/KeypressContext.js";
+import { AgentEventBus } from "@dexto/core";
+import { createUserMessage } from "../utils/messageFormatting.js";
+import { InputContainer } from "../containers/InputContainer.js";
+vi.mock("../components/input/InputArea.js", () => ({ InputArea: () => null }));
+const agent = {
+  getCurrentLLMConfig: () => ({ provider: "openai", model: "gpt-5" }),
+  getSessionHistory: async () => [],
+  on: () => {
+  }
+};
+function mountState(initialSessionId, backend = agent, initialPrompt, withInput = false) {
+  const inputRef = createRef();
+  const stdout = Object.assign(new PassThrough(), { columns: 120, rows: 40, isTTY: false });
+  let state;
+  let output = "";
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+  function Probe() {
+    state = useCLIState({
+      agent: backend,
+      initialSessionId,
+      initialBypassPermissions: true,
+      startupInfo: {
+        connectedServers: { count: 0, names: [] },
+        failedConnections: [],
+        toolCount: 0,
+        logFile: null
+      }
+    });
+    const transcript = createElement(Static, {
+      items: state.visibleMessages,
+      children: (message) => createElement(Text, { key: message.id }, message.content)
+    });
+    return createElement(
+      Fragment,
+      null,
+      transcript,
+      withInput ? createElement(InputContainer, {
+        ...state,
+        ref: inputRef,
+        initialPrompt,
+        configFilePath: null
+      }) : null
+    );
+  }
+  const view = render(createElement(KeypressProvider, null, createElement(Probe)), {
+    stdout,
+    patchConsole: false,
+    exitOnCtrlC: false
+  });
+  return {
+    getState() {
+      if (!state) throw new Error("Not mounted");
+      return state;
+    },
+    submit(text) {
+      if (!inputRef.current) throw new Error("Input not mounted");
+      return inputRef.current.submit(text);
+    },
+    output() {
+      return output;
+    },
+    close() {
+      view.unmount();
+      view.cleanup();
+    }
+  };
+}
+describe("TUI session permission modes", () => {
+  it("keeps startup auto-approval when the first session is created, then resets on switch", async () => {
+    const screen = mountState(null);
+    try {
+      await vi.waitFor(() => expect(screen.getState().ui.bypassPermissions).toBe(true));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a", hasActiveSession: true }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+      expect(screen.getState().ui.bypassPermissions).toBe(true);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b", hasActiveSession: true }));
+      await vi.waitFor(() => expect(screen.getState().ui.bypassPermissions).toBe(false));
+    } finally {
+      screen.close();
+    }
+  });
+  it("resets accept-edits mode when a conversation is cleared", async () => {
+    const screen = mountState("a");
+    try {
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+      screen.getState().setUi((previous) => ({
+        ...previous,
+        autoApproveEdits: true,
+        bypassPermissions: false
+      }));
+      await vi.waitFor(() => expect(screen.getState().ui.autoApproveEdits).toBe(true));
+      screen.getState().setSession((previous) => ({ ...previous, id: null, hasActiveSession: false }));
+      await vi.waitFor(() => expect(screen.getState().ui.autoApproveEdits).toBe(false));
+    } finally {
+      screen.close();
+    }
+  });
+});
+describe("TUI resumed history", () => {
+  it("waits for the actual history snapshot before persisting the startup prompt", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const persisted = [
+      { role: "user", content: [{ type: "text", text: "earlier task" }] }
+    ];
+    const stream = vi.fn(async function* (content) {
+      persisted.push({ role: "user", content: [{ type: "text", text: content }] });
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: vi.fn() },
+      getSessionHistory: vi.fn(async () => {
+        await ready;
+        return [...persisted];
+      })
+    };
+    const screen = mountState("a", backend, "startup task", true);
+    try {
+      await vi.waitFor(() => expect(backend.getSessionHistory).toHaveBeenCalled());
+      expect(stream).not.toHaveBeenCalled();
+      screen.getState().buffer.setText("new draft");
+      await vi.waitFor(() => expect(screen.getState().input.value).toBe("new draft"));
+      releaseHistory();
+      await vi.waitFor(() => expect(stream).toHaveBeenCalledTimes(1));
+      expect(screen.getState().messages.map((message) => message.content)).toEqual([
+        "earlier task",
+        "startup task"
+      ]);
+      expect(screen.getState().input.value).toBe("new draft");
+      expect(screen.output().match(/startup task/g)).toHaveLength(1);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  it("cancels the startup prompt after switching away from its pending resumed session", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "b", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: vi.fn() },
+      getSessionHistory: vi.fn(async () => {
+        await ready;
+        return [];
+      })
+    };
+    const screen = mountState("a", backend, "startup task for a", true);
+    try {
+      await vi.waitFor(() => expect(backend.getSessionHistory).toHaveBeenCalledWith("a"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+      expect(stream).not.toHaveBeenCalled();
+      await screen.submit("manual task for b");
+      expect(stream).toHaveBeenCalledExactlyOnceWith("manual task for b", "b");
+      releaseHistory();
+      screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+      await vi.waitFor(() => expect(screen.getState().ui.isThinking).toBe(true));
+      expect(stream).toHaveBeenCalledTimes(1);
+      expect(screen.getState().messages.map((message) => message.content)).toEqual([
+        "manual task for b"
+      ]);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  it("still creates a first session for an ordinary startup prompt", async () => {
+    const createSession = vi.fn(async () => ({ id: "created" }));
+    const stream = vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "created", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      createSession,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: vi.fn() }
+    };
+    const screen = mountState(null, backend, "new startup task", true);
+    try {
+      await vi.waitFor(
+        () => expect(stream).toHaveBeenCalledExactlyOnceWith("new startup task", "created")
+      );
+      expect(createSession).toHaveBeenCalledTimes(1);
+      expect(screen.getState().session.id).toBe("created");
+    } finally {
+      screen.close();
+    }
+  });
+  it("preserves multiple submissions and a newer draft while resumed history is pending", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: vi.fn() },
+      getSessionHistory: vi.fn(async () => {
+        await ready;
+        return [{ role: "user", content: [{ type: "text", text: "earlier task" }] }];
+      })
+    };
+    const screen = mountState("a", backend, "startup task", true);
+    try {
+      await vi.waitFor(() => expect(backend.getSessionHistory).toHaveBeenCalled());
+      const first = screen.submit("first task");
+      const second = screen.submit("second task");
+      const repeated = screen.submit("first task");
+      screen.getState().buffer.setText("newer draft");
+      await vi.waitFor(() => expect(screen.getState().input.value).toBe("newer draft"));
+      expect(stream).not.toHaveBeenCalled();
+      releaseHistory();
+      await Promise.all([first, second, repeated]);
+      await vi.waitFor(() => expect(stream).toHaveBeenCalledTimes(4));
+      expect(stream.mock.calls.map(([content]) => content)).toEqual([
+        "startup task",
+        "first task",
+        "second task",
+        "first task"
+      ]);
+      expect(screen.getState().input.history).toEqual([
+        "earlier task",
+        "startup task",
+        "first task",
+        "second task",
+        "first task"
+      ]);
+      expect(screen.getState().input.value).toBe("newer draft");
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  it("releases deferred submission after history failure without hydrating again on return", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: vi.fn() },
+      getSessionHistory: vi.fn(async () => {
+        await ready;
+        throw new Error("history unavailable");
+      })
+    };
+    const screen = mountState("a", backend, void 0, true);
+    try {
+      await vi.waitFor(() => expect(backend.getSessionHistory).toHaveBeenCalled());
+      const pending = screen.submit("continue anyway");
+      expect(stream).not.toHaveBeenCalled();
+      releaseHistory();
+      await pending;
+      await vi.waitFor(() => expect(stream).toHaveBeenCalledTimes(1));
+      expect(screen.getState().messages.map((message) => message.content)).toEqual([
+        "Error: history unavailable",
+        "continue anyway"
+      ]);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+      expect(backend.getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  it("does not send deferred submissions into a different session", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = vi.fn();
+    const backend = {
+      ...agent,
+      stream,
+      getSessionHistory: vi.fn(async () => {
+        await ready;
+        return [];
+      })
+    };
+    const screen = mountState("a", backend, void 0, true);
+    try {
+      await vi.waitFor(() => expect(backend.getSessionHistory).toHaveBeenCalled());
+      const pending = screen.submit("session a task");
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+      await pending;
+      releaseHistory();
+      expect(stream).not.toHaveBeenCalled();
+      expect(screen.getState().messages).toEqual([]);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  it("preserves resumed history and a prompt submitted while history is loading", async () => {
+    let finishHistory = () => {
+      throw new Error("History request not started");
+    };
+    const history = new Promise((resolve) => {
+      finishHistory = resolve;
+    });
+    const getSessionHistory = vi.fn(() => history);
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await vi.waitFor(() => expect(getSessionHistory).toHaveBeenCalledWith("a"));
+      const prompt = createUserMessage("continue this task");
+      screen.getState().setMessages((previous) => [...previous, prompt]);
+      screen.getState().setInput((previous) => ({
+        ...previous,
+        history: [...previous.history, prompt.content]
+      }));
+      await vi.waitFor(() => expect(screen.getState().messages).toEqual([prompt]));
+      expect(screen.output()).not.toContain("continue this task");
+      finishHistory([
+        { role: "user", content: [{ type: "text", text: "earlier task" }] },
+        {
+          role: "assistant",
+          assistantOutput: { status: "complete" },
+          content: [{ type: "text", text: "earlier answer" }]
+        }
+      ]);
+      await vi.waitFor(
+        () => expect(screen.getState().messages.map((message) => message.content)).toEqual([
+          "earlier task",
+          "earlier answer",
+          "continue this task"
+        ])
+      );
+      expect(screen.getState().input.history).toEqual(["earlier task", "continue this task"]);
+      await vi.waitFor(() => expect(screen.output()).toContain("continue this task"));
+      expect(screen.output().indexOf("earlier task")).toBeLessThan(
+        screen.output().indexOf("continue this task")
+      );
+      expect(screen.output().indexOf("earlier answer")).toBeLessThan(
+        screen.output().indexOf("continue this task")
+      );
+      expect(screen.output().match(/continue this task/g)).toHaveLength(1);
+      expect(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  it("discards pending resumed history after switching to another session", async () => {
+    let finishHistory = () => {
+      throw new Error("History request not started");
+    };
+    const history = new Promise((resolve) => {
+      finishHistory = resolve;
+    });
+    const getSessionHistory = vi.fn(() => history);
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await vi.waitFor(() => expect(getSessionHistory).toHaveBeenCalledWith("a"));
+      screen.getState().setSession((previous) => ({
+        ...previous,
+        id: "b",
+        hasActiveSession: true
+      }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+      const prompt = createUserMessage("session b prompt");
+      screen.getState().setMessages([prompt]);
+      screen.getState().setInput((previous) => ({ ...previous, history: [prompt.content] }));
+      await vi.waitFor(() => expect(screen.output()).toContain("session b prompt"));
+      finishHistory([
+        { role: "user", content: [{ type: "text", text: "session a history" }] }
+      ]);
+      await history;
+      screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+      await vi.waitFor(() => expect(screen.getState().ui.isThinking).toBe(true));
+      expect(screen.getState().messages).toEqual([prompt]);
+      expect(screen.getState().input.history).toEqual(["session b prompt"]);
+      expect(screen.output()).not.toContain("session a history");
+      expect(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  it("loads ordinary resumed history once without replacing a current input draft", async () => {
+    const getSessionHistory = vi.fn(
+      async () => [
+        { role: "user", content: [{ type: "text", text: "earlier task" }] },
+        {
+          role: "assistant",
+          assistantOutput: { status: "complete" },
+          content: [{ type: "text", text: "earlier answer" }]
+        }
+      ]
+    );
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await vi.waitFor(() => expect(screen.getState().messages).toHaveLength(2));
+      screen.getState().buffer.setText("next task draft");
+      await vi.waitFor(() => expect(screen.getState().input.value).toBe("next task draft"));
+      expect(screen.getState().input.history).toEqual(["earlier task"]);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a" }));
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+      expect(screen.getState().messages.map((message) => message.content)).toEqual([
+        "earlier task",
+        "earlier answer"
+      ]);
+      expect(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  it("releases submitted messages to static output when resumed history fails", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const getSessionHistory = vi.fn(async () => {
+      await ready;
+      throw new Error("history unavailable");
+    });
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await vi.waitFor(() => expect(getSessionHistory).toHaveBeenCalledWith("a"));
+      const prompt = createUserMessage("continue without history");
+      screen.getState().setMessages([prompt]);
+      await vi.waitFor(() => expect(screen.getState().messages).toEqual([prompt]));
+      expect(screen.output()).not.toContain(prompt.content);
+      releaseHistory();
+      await vi.waitFor(() => expect(screen.output()).toContain("Error: history unavailable"));
+      expect(screen.output()).toContain(prompt.content);
+      expect(screen.output().match(/continue without history/g)).toHaveLength(1);
+      expect(screen.getState().messages.map((message) => message.content)).toEqual([
+        prompt.content,
+        "Error: history unavailable"
+      ]);
+    } finally {
+      screen.close();
+    }
+  });
+});
+describe("TUI session queue isolation", () => {
+  it("keeps a current-session queue snapshot while the composer changes", async () => {
+    const events = new AgentEventBus();
+    let release = () => {
+    };
+    const pending = new Promise((resolve) => {
+      release = resolve;
+    });
+    const messages = [
+      { id: "queued", content: [{ type: "text", text: "queued task" }], queuedAt: 1 }
+    ];
+    const backend = {
+      ...agent,
+      on: events.on.bind(events),
+      getSteerMessages: vi.fn(async () => pending)
+    };
+    const screen = mountState("a", backend);
+    try {
+      await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+      events.emit("message:queued", {
+        sessionId: "a",
+        queue: "steer",
+        id: "queued",
+        position: 1
+      });
+      screen.getState().buffer.setText("a newer draft");
+      await vi.waitFor(() => expect(screen.getState().input.value).toBe("a newer draft"));
+      release(messages);
+      await vi.waitFor(() => expect(screen.getState().steerMessages).toEqual(messages));
+      expect(screen.getState().input.value).toBe("a newer draft");
+    } finally {
+      release([]);
+      screen.close();
+    }
+  });
+  it.each(["steer", "follow-up"])(
+    "ignores %s queue events from another session",
+    async (queue) => {
+      const events = new AgentEventBus();
+      const getMessages = vi.fn(async () => []);
+      const backend = {
+        ...agent,
+        on: events.on.bind(events),
+        getSteerMessages: getMessages,
+        getFollowUpMessages: getMessages
+      };
+      const screen = mountState("a", backend);
+      try {
+        await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+        events.emit("message:queued", { sessionId: "b", queue, id: "other", position: 1 });
+        events.emit("message:removed", { sessionId: "b", queue, id: "other" });
+        expect(getMessages).not.toHaveBeenCalled();
+      } finally {
+        screen.close();
+      }
+    }
+  );
+  it.each(["steer", "follow-up"])(
+    "discards a pending %s snapshot after switching sessions",
+    async (queue) => {
+      const events = new AgentEventBus();
+      let release = () => {
+      };
+      const pending = new Promise((resolve) => {
+        release = resolve;
+      });
+      const current = [
+        { id: "current", content: [{ type: "text", text: "current task" }], queuedAt: 1 }
+      ];
+      const getMessages = vi.fn(
+        async (sessionId) => sessionId === "a" ? pending : current
+      );
+      const backend = {
+        ...agent,
+        on: events.on.bind(events),
+        getSteerMessages: getMessages,
+        getFollowUpMessages: getMessages
+      };
+      const screen = mountState("a", backend);
+      const visibleQueue = () => queue === "steer" ? screen.getState().steerMessages : screen.getState().queuedMessages;
+      try {
+        await vi.waitFor(() => expect(screen.getState().session.id).toBe("a"));
+        events.emit("message:queued", { sessionId: "a", queue, id: "old", position: 1 });
+        expect(getMessages).toHaveBeenCalledWith("a");
+        screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+        await vi.waitFor(() => expect(screen.getState().session.id).toBe("b"));
+        events.emit("message:queued", {
+          sessionId: "b",
+          queue,
+          id: "current",
+          position: 1
+        });
+        await vi.waitFor(() => expect(visibleQueue()).toEqual(current));
+        release([
+          { id: "old", content: [{ type: "text", text: "old task" }], queuedAt: 0 }
+        ]);
+        await pending;
+        screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+        await vi.waitFor(() => expect(screen.getState().ui.isThinking).toBe(true));
+        expect(visibleQueue()).toEqual(current);
+      } finally {
+        release([]);
+        screen.close();
+      }
+    }
+  );
+});

package/dist/index.d.cts

@@ -229,6 +229,8 @@ interface TuiEffectiveConfig {
     [key: string]: unknown;
 }
 interface TuiAgentBackend extends Pick<DextoAgent, 'stream' | 'stop' | 'run' | 'listSessions' | 'getSessionMetadata' | 'getSessionHistory' | 'getSessionTitle' | 'setSessionTitle' | 'generateSessionTitle' | 'forkSession' | 'getCurrentLLMConfig' | 'hasSessionLLMOverride' | 'switchLLM' | 'getSupportedProviders' | 'getSupportedModels' | 'getContextStats' | 'clearContext' | 'compactContext' | 'steer' | 'followUp' | 'getSteerMessages' | 'getFollowUpMessages' | 'removeSteerMessage' | 'removeFollowUpMessage' | 'clearSteerQueue' | 'clearFollowUpQueue' | 'cancel' | 'searchMessages' | 'listPrompts' | 'refreshPrompts' | 'resolvePrompt' | 'getSystemPrompt' | 'loadToolkits' | 'listResources' | 'setLogLevel' | 'getAllTools' | 'getEnabledTools' | 'getAllMcpTools' | 'setGlobalDisabledTools' | 'setSessionDisabledTools' | 'setSessionAutoApproveTools' | 'getSessionAutoApproveTools' | 'getMcpServersWithStatus' | 'addMcpServer' | 'enableMcpServer' | 'disableMcpServer' | 'removeMcpServer' | 'restartMcpServer' | 'getMcpClients' | 'getMcpFailedConnections'> {
+    getSessionApprovals?: DextoAgent['getSessionApprovals'];
+    revokeSessionApproval?: DextoAgent['revokeSessionApproval'];
     createSession: (sessionId?: string) => Promise<{
         id: string;
         logger: Pick<RootLogger, 'getLevel' | 'getLogFilePath'>;

package/dist/interactive-commands/commands.test.cjs

@@ -22,6 +22,12 @@ function createAgent(capabilities) {
   };
 }
 (0, import_vitest.describe)("executeCommand", () => {
+  (0, import_vitest.it)("does not advertise local permission controls for an unsupported backend", async () => {
+    const agent = createAgent();
+    (0, import_vitest.expect)(await (0, import_commands.executeCommand)("permissions", [], agent)).toBe(
+      "\u26A0\uFE0F  Command /permissions is not available for this chat target."
+    );
+  });
   (0, import_vitest.it)("returns unknown-command guidance when prompts are unsupported and the command is not real", async () => {
     const agent = createAgent({ prompts: false });
     const result = await (0, import_commands.executeCommand)("typoed-command", [], agent);

package/dist/interactive-commands/commands.test.js

@@ -21,6 +21,12 @@ function createAgent(capabilities) {
   };
 }
 describe("executeCommand", () => {
+  it("does not advertise local permission controls for an unsupported backend", async () => {
+    const agent = createAgent();
+    expect(await executeCommand("permissions", [], agent)).toBe(
+      "\u26A0\uFE0F  Command /permissions is not available for this chat target."
+    );
+  });
   it("returns unknown-command guidance when prompts are unsupported and the command is not real", async () => {
     const agent = createAgent({ prompts: false });
     const result = await executeCommand("typoed-command", [], agent);

package/dist/interactive-commands/tool-commands.cjs

@@ -22,6 +22,13 @@ __export(tool_commands_exports, {
 });
 module.exports = __toCommonJS(tool_commands_exports);
 const toolCommands = [
+  {
+    name: "permissions",
+    description: "Choose approval mode and revoke remembered session permissions",
+    usage: "/permissions",
+    category: "Tool Management",
+    handler: async () => true
+  },
   {
     name: "tools",
     description: "Browse available tools interactively",

package/dist/interactive-commands/tool-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-commands.d.ts","sourceRoot":"","sources":["../../src/interactive-commands/tool-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,qBAAqB,CAAC;AAG7E;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,iBAAiB,EAe3C,CAAC"}
+{"version":3,"file":"tool-commands.d.ts","sourceRoot":"","sources":["../../src/interactive-commands/tool-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,qBAAqB,CAAC;AAG7E;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,iBAAiB,EAsB3C,CAAC"}

package/dist/interactive-commands/tool-commands.js

@@ -1,4 +1,11 @@
 const toolCommands = [
+  {
+    name: "permissions",
+    description: "Choose approval mode and revoke remembered session permissions",
+    usage: "/permissions",
+    category: "Tool Management",
+    handler: async () => true
+  },
   {
     name: "tools",
     description: "Browse available tools interactively",

package/dist/services/processStream.cjs

@@ -766,7 +766,7 @@ ${import_chalk.default.dim(runningDescription)}`;
           const bypassPermissions = options.bypassPermissionsRef.current;
           const autoApproveEdits = options.autoApproveEditsRef.current;
           const { eventBus } = options;
-          if (bypassPermissions && (event.type === import_core.ApprovalType.TOOL_APPROVAL || event.type === import_core.ApprovalType.COMMAND_APPROVAL)) {
+          if (bypassPermissions && event.autoApproval !== "disallowed" && (event.type === import_core.ApprovalType.TOOL_APPROVAL || event.type === import_core.ApprovalType.COMMAND_APPROVAL)) {
             if (event.type === import_core.ApprovalType.TOOL_APPROVAL) {
               const { toolName } = event.metadata;
               if (toolName === "plan_create" || toolName === "plan_review") {
@@ -786,7 +786,7 @@ ${import_chalk.default.dim(runningDescription)}`;
             });
             break;
           }
-          if (autoApproveEdits && event.type === import_core.ApprovalType.TOOL_APPROVAL) {
+          if (autoApproveEdits && event.autoApproval !== "disallowed" && event.type === import_core.ApprovalType.TOOL_APPROVAL) {
             const { toolName, approvalKey } = event.metadata;
             if (approvalKey === void 0 && (0, import_toolUtils.isAutoApprovableInEditMode)(toolName)) {
               eventBus.emit("approval:response", {
@@ -811,6 +811,8 @@ ${import_chalk.default.dim(runningDescription)}`;
               timestamp: event.timestamp,
               metadata: event.metadata
             };
+            if (event.autoApproval !== void 0)
+              newApproval.autoApproval = event.autoApproval;
             if (event.sessionId !== void 0) {
               newApproval.sessionId = event.sessionId;
             }