pi-ui-extend 0.1.13 → 0.1.15

package/dist/app/extensions/extension-ui-controller.js

@@ -6,20 +6,15 @@ export class ExtensionUiController {
     host;
     extensionWidgets = new Map();
     terminalInputHandlers = new Set();
-    activeCustomUi;
-    aboveInputRenderer = {
-        set: (key, content) => {
-            this.setAboveInputWidget(key, content);
-        },
-        clear: (key) => {
-            this.clearAboveInputWidget(key);
-        },
-    };
+    activeCustomUis = new Map();
     constructor(host) {
         this.host = host;
     }
     get widgets() {
-        return this.extensionWidgets;
+        const activeScopeKey = this.activeScopeKey();
+        return new Map([...this.extensionWidgets.entries()]
+            .filter(([, widget]) => widget.scopeKey === activeScopeKey)
+            .map(([scopedKey, widget]) => [this.unscopedWidgetKey(scopedKey, widget.scopeKey), widget]));
     }
     createExtensionTheme() {
         const colors = this.host.theme.colors;
@@ -47,44 +42,54 @@ export class ExtensionUiController {
         };
     }
     setWidget(key, content, options) {
-        const existing = this.extensionWidgets.get(key);
+        const scopeKey = this.normalizeScopeKey(options?.scopeKey);
+        const scopedKey = this.scopedWidgetKey(scopeKey, key);
+        const existing = this.extensionWidgets.get(scopedKey);
         if (existing)
             this.invalidateWidget(existing);
         if (content === undefined) {
-            this.extensionWidgets.delete(key);
+            this.extensionWidgets.delete(scopedKey);
             if (this.host.isRunning())
                 this.host.render();
             return;
         }
         if (!Array.isArray(content) && typeof content !== "function")
             return;
-        this.extensionWidgets.set(key, {
+        this.extensionWidgets.set(scopedKey, {
             key,
+            scopeKey,
             placement: options?.placement === "belowEditor" ? "belowEditor" : "aboveEditor",
             content: content,
         });
         if (this.host.isRunning())
             this.host.render();
     }
-    clearWidgets() {
-        this.cancelActiveCustomUi();
-        for (const widget of this.extensionWidgets.values())
+    clearWidgets(scopeKey, options = {}) {
+        const normalizedScopeKey = this.normalizeScopeKey(scopeKey);
+        if (options.cancelCustomUi !== false)
+            this.cancelActiveCustomUi(normalizedScopeKey);
+        for (const [key, widget] of this.extensionWidgets.entries()) {
+            if (widget.scopeKey !== normalizedScopeKey)
+                continue;
             this.invalidateWidget(widget);
-        this.extensionWidgets.clear();
+            this.extensionWidgets.delete(key);
+        }
     }
     suppressWidget(key) {
-        const widget = this.extensionWidgets.get(key);
+        const scopedKey = this.scopedWidgetKey(this.activeScopeKey(), key);
+        const widget = this.extensionWidgets.get(scopedKey);
         if (!widget)
             return;
         this.invalidateWidget(widget);
-        this.extensionWidgets.delete(key);
+        this.extensionWidgets.delete(scopedKey);
     }
     handleTerminalInput(data) {
-        if (this.activeCustomUi) {
+        const active = this.activeCustomUiForActiveScope();
+        if (active) {
             if (data === "\u0003")
                 return { consume: false };
             try {
-                const result = this.activeCustomUi.component.handleInput?.(data);
+                const result = active.component.handleInput?.(data);
                 if (result && typeof result === "object") {
                     return {
                         consume: result.consume !== false,
@@ -98,7 +103,10 @@ export class ExtensionUiController {
             return { consume: true };
         }
         let current = data;
-        for (const handler of [...this.terminalInputHandlers]) {
+        const activeScopeKey = this.activeScopeKey();
+        for (const { scopeKey, handler } of [...this.terminalInputHandlers]) {
+            if (scopeKey !== activeScopeKey)
+                continue;
             const result = handler(current);
             if (result?.data !== undefined)
                 current = result.data;
@@ -108,7 +116,7 @@ export class ExtensionUiController {
         return current === data ? { consume: false } : { consume: false, data: current };
     }
     renderActiveCustomUi(width) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return undefined;
         try {
@@ -119,7 +127,7 @@ export class ExtensionUiController {
         }
     }
     activeCustomUiUsesEditor() {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -130,7 +138,7 @@ export class ExtensionUiController {
         }
     }
     handleCustomUiMouse(event) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -142,13 +150,14 @@ export class ExtensionUiController {
         }
     }
     widgetTuiHandle() {
+        const activeScopeToastNotifier = this.host.toastNotifierForScope?.(this.activeScopeKey()) ?? this.host.toastNotifier;
         return {
             requestRender: () => {
                 if (this.host.isRunning())
                     this.host.render();
             },
-            showToast: this.host.toastNotifier.show,
-            toast: this.host.toastNotifier,
+            showToast: activeScopeToastNotifier.show,
+            toast: activeScopeToastNotifier,
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             pix: {
@@ -157,9 +166,11 @@ export class ExtensionUiController {
             },
         };
     }
-    createExtensionUIContext() {
+    createExtensionUIContext(scopeKey) {
+        const contextScopeKey = this.normalizeScopeKey(scopeKey);
+        const scopedToastNotifier = this.host.toastNotifierForScope?.(contextScopeKey) ?? this.host.toastNotifier;
         const notify = (message, type) => {
-            this.host.showToast(message, isToastKind(type) ? type : "info");
+            this.host.showToast(message, isToastKind(type) ? type : "info", { scopeKey: contextScopeKey });
         };
         const extensionTheme = this.createExtensionTheme();
         const renderIfRunning = () => {
@@ -169,17 +180,24 @@ export class ExtensionUiController {
         return {
             select: async (title, options, opts) => await this.selectDialog(title, options, opts),
             confirm: async (title, message, opts) => await this.confirmDialog(title, message, opts),
-            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts),
+            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts, contextScopeKey),
             notify,
-            toast: this.host.toastNotifier,
-            aboveInput: this.aboveInputRenderer,
+            toast: scopedToastNotifier,
+            aboveInput: {
+                set: (key, content) => {
+                    this.setAboveInputWidget(key, content, contextScopeKey);
+                },
+                clear: (key) => {
+                    this.clearAboveInputWidget(key, contextScopeKey);
+                },
+            },
             renderAboveInput: (key, content) => {
-                this.setAboveInputWidget(key, content);
+                this.setAboveInputWidget(key, content, contextScopeKey);
             },
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             onTerminalInput: (handler) => {
-                const terminalInputHandler = handler;
+                const terminalInputHandler = { scopeKey: contextScopeKey, handler: handler };
                 this.terminalInputHandlers.add(terminalInputHandler);
                 return () => {
                     this.terminalInputHandlers.delete(terminalInputHandler);
@@ -187,13 +205,13 @@ export class ExtensionUiController {
             },
             setStatus: (_key, text) => {
                 if (text)
-                    this.host.showToast(text, "info");
+                    this.host.showToast(text, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
             setWorkingMessage: (message) => {
                 if (message)
-                    this.host.showToast(message, "info");
+                    this.host.showToast(message, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
@@ -201,7 +219,7 @@ export class ExtensionUiController {
             setWorkingIndicator: () => undefined,
             setHiddenThinkingLabel: () => undefined,
             setWidget: ((key, content, options) => {
-                this.setWidget(key, content, options);
+                this.setWidget(key, content, { ...options, scopeKey: contextScopeKey });
             }),
             setFooter: () => undefined,
             setHeader: () => undefined,
@@ -209,7 +227,7 @@ export class ExtensionUiController {
                 process.title = title;
                 renderIfRunning();
             },
-            custom: (async (factory) => await this.showCustomUi(factory)),
+            custom: (async (factory) => await this.showCustomUi(factory, { scopeKey: contextScopeKey })),
             pasteToEditor: (text) => {
                 this.host.setInput(text);
                 renderIfRunning();
@@ -219,7 +237,7 @@ export class ExtensionUiController {
                 renderIfRunning();
             },
             getEditorText: () => this.host.getInput(),
-            editor: async (title, prefill) => await this.editorDialog(title, prefill),
+            editor: async (title, prefill) => await this.editorDialog(title, prefill, contextScopeKey),
             addAutocompleteProvider: () => undefined,
             setEditorComponent: () => undefined,
             getEditorComponent: () => undefined,
@@ -241,11 +259,11 @@ export class ExtensionUiController {
             },
         };
     }
-    setAboveInputWidget(key, content) {
-        this.setWidget(key, content, { placement: "aboveEditor" });
+    setAboveInputWidget(key, content, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, content, { placement: "aboveEditor", scopeKey });
     }
-    clearAboveInputWidget(key) {
-        this.setWidget(key, undefined, { placement: "aboveEditor" });
+    clearAboveInputWidget(key, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, undefined, { placement: "aboveEditor", scopeKey });
     }
     async selectDialog(title, options, opts) {
         if (opts?.signal?.aborted)
@@ -265,7 +283,7 @@ export class ExtensionUiController {
         });
         return selected === true;
     }
-    async inputDialog(title, placeholder, opts) {
+    async inputDialog(title, placeholder, opts, scopeKey = this.activeScopeKey()) {
         if (opts?.signal?.aborted)
             return undefined;
         return await this.editorBackedDialog({
@@ -274,21 +292,21 @@ export class ExtensionUiController {
             mode: "input",
             ...(placeholder === undefined ? {} : { placeholder }),
             ...(opts === undefined ? {} : { opts }),
-        });
+        }, scopeKey);
     }
-    async editorDialog(title, prefill = "") {
+    async editorDialog(title, prefill = "", scopeKey = this.activeScopeKey()) {
         return await this.editorBackedDialog({
             title,
             initialValue: prefill,
             mode: "editor",
-        });
+        }, scopeKey);
     }
-    async editorBackedDialog(options) {
+    async editorBackedDialog(options, scopeKey = this.activeScopeKey()) {
         if (options.opts?.signal?.aborted)
             return undefined;
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = this.host.getInput();
         this.host.setInput(options.initialValue);
@@ -315,9 +333,9 @@ export class ExtensionUiController {
                     return { consume: false, data };
                 },
             };
-        }, { savedInput });
+        }, { savedInput, scopeKey });
         return await this.withDialogAutoDismiss(promise, options.opts, () => {
-            this.cancelActiveCustomUi();
+            this.cancelActiveCustomUi(scopeKey);
         });
     }
     renderEditorBackedDialog(options, width) {
@@ -356,7 +374,8 @@ export class ExtensionUiController {
     async showCustomUi(factory, options = {}) {
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        const scopeKey = this.normalizeScopeKey(options.scopeKey);
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = options.savedInput ?? this.host.getInput();
         return await new Promise((resolve, reject) => {
@@ -365,7 +384,7 @@ export class ExtensionUiController {
                 if (settled)
                     return;
                 settled = true;
-                this.finishActiveCustomUi(value, { resolve: true });
+                this.finishActiveCustomUi(scopeKey, value, { resolve: true });
                 resolve(value);
             };
             void (async () => {
@@ -375,8 +394,9 @@ export class ExtensionUiController {
                         component.dispose?.();
                         return;
                     }
-                    this.activeCustomUi = {
+                    this.activeCustomUis.set(scopeKey, {
                         key: CUSTOM_UI_WIDGET_KEY,
+                        scopeKey,
                         component,
                         savedInput,
                         resolve: (value) => {
@@ -391,7 +411,7 @@ export class ExtensionUiController {
                             settled = true;
                             reject(error);
                         },
-                    };
+                    });
                     if (this.host.isRunning())
                         this.host.render();
                 }
@@ -404,17 +424,20 @@ export class ExtensionUiController {
             })();
         });
     }
-    cancelActiveCustomUi() {
-        this.finishActiveCustomUi(undefined, { resolve: true });
+    cancelActiveCustomUi(scopeKey = this.activeScopeKey()) {
+        this.finishActiveCustomUi(scopeKey, undefined, { resolve: true });
     }
     rejectActiveCustomUi(error) {
-        this.finishActiveCustomUi(error, { resolve: false });
+        const active = this.activeCustomUiForActiveScope();
+        if (!active)
+            return;
+        this.finishActiveCustomUi(active.scopeKey, error, { resolve: false });
     }
-    finishActiveCustomUi(value, options) {
-        const active = this.activeCustomUi;
+    finishActiveCustomUi(scopeKey, value, options) {
+        const active = this.activeCustomUis.get(scopeKey);
         if (!active)
             return;
-        this.activeCustomUi = undefined;
+        this.activeCustomUis.delete(scopeKey);
         if (this.host.getInput() !== active.savedInput)
             this.host.setInput(active.savedInput);
         try {
@@ -436,6 +459,21 @@ export class ExtensionUiController {
         if (this.host.isRunning())
             this.host.render();
     }
+    activeCustomUiForActiveScope() {
+        return this.activeCustomUis.get(this.activeScopeKey());
+    }
+    activeScopeKey() {
+        return this.normalizeScopeKey(this.host.activeExtensionUiScope?.());
+    }
+    normalizeScopeKey(scopeKey) {
+        return scopeKey ?? "";
+    }
+    scopedWidgetKey(scopeKey, key) {
+        return `${scopeKey.length}:${scopeKey}:${key}`;
+    }
+    unscopedWidgetKey(scopedKey, scopeKey) {
+        return scopedKey.slice(`${scopeKey.length}:${scopeKey}:`.length);
+    }
     invalidateWidget(widget) {
         try {
             widget.component?.dispose?.();

package/dist/app/input/input-action-controller.d.ts

@@ -39,6 +39,7 @@ export declare class AppInputActionController {
     queueInputFromEditor(): Promise<void>;
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
+    private closeActiveGlobalUi;
     private abortStreamingSession;
     private restoreSessionState;
     private sessionActivity;

package/dist/app/input/input-action-controller.js

@@ -63,6 +63,8 @@ export class AppInputActionController {
         await this.host.stop();
     }
     async handleEscape() {
+        if (this.closeActiveGlobalUi())
+            return;
         const session = this.host.runtime()?.session;
         if (session?.isCompacting) {
             this.host.setStatus("aborting compaction");
@@ -76,8 +78,12 @@ export class AppInputActionController {
                 await this.abortStreamingSession(runtime, { stopIfAlreadyAborting: false });
             return;
         }
-        if (this.popupMenus.syncActivePopupMenu())
-            this.popupMenus.cancelActivePopupMenu();
+    }
+    closeActiveGlobalUi() {
+        if (!this.popupMenus.syncActivePopupMenu())
+            return false;
+        this.popupMenus.cancelActivePopupMenu();
+        return true;
     }
     async abortStreamingSession(runtime, options) {
         const session = runtime.session;

package/dist/app/logger.d.ts

@@ -0,0 +1,25 @@
+export declare const PIX_LOG_MAX_LINES = 1000;
+export type PixLogLevel = "debug" | "info" | "warn" | "error";
+export type PixLogDetails = Record<string, unknown>;
+export type PixFileLoggerOptions = {
+    logPath?: string;
+    maxLines?: number;
+};
+export declare function getPixLogPath(homeDir?: string): string;
+export declare class PixFileLogger {
+    readonly logPath: string;
+    private readonly maxLines;
+    private pending;
+    constructor(options?: PixFileLoggerOptions);
+    log(level: PixLogLevel, event: string, details?: PixLogDetails): Promise<void>;
+    debug(event: string, details?: PixLogDetails): Promise<void>;
+    info(event: string, details?: PixLogDetails): Promise<void>;
+    warn(event: string, details?: PixLogDetails): Promise<void>;
+    error(event: string, details?: PixLogDetails): Promise<void>;
+    flush(): Promise<void>;
+    private formatLine;
+    private writeLine;
+}
+export declare const pixLogger: PixFileLogger;
+export declare function logPixEvent(level: PixLogLevel, event: string, details?: PixLogDetails): void;
+export declare function trimLogFile(logPath: string, maxLines?: number): Promise<void>;

package/dist/app/logger.js

@@ -0,0 +1,90 @@
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const PIX_LOG_MAX_LINES = 1000;
+export function getPixLogPath(homeDir = homedir()) {
+    return join(homeDir, ".config", "pi", "pix.log");
+}
+export class PixFileLogger {
+    logPath;
+    maxLines;
+    pending = Promise.resolve();
+    constructor(options = {}) {
+        this.logPath = options.logPath ?? getPixLogPath();
+        this.maxLines = Math.max(1, Math.floor(options.maxLines ?? PIX_LOG_MAX_LINES));
+    }
+    log(level, event, details = {}) {
+        const line = this.formatLine(level, event, details);
+        this.pending = this.pending
+            .then(() => this.writeLine(line))
+            .catch(() => undefined);
+        return this.pending;
+    }
+    debug(event, details) {
+        return this.log("debug", event, details);
+    }
+    info(event, details) {
+        return this.log("info", event, details);
+    }
+    warn(event, details) {
+        return this.log("warn", event, details);
+    }
+    error(event, details) {
+        return this.log("error", event, details);
+    }
+    async flush() {
+        await this.pending;
+    }
+    formatLine(level, event, details) {
+        return `${new Date().toISOString()} ${level.toUpperCase()} ${sanitizeToken(event)} ${safeJson(details)}\n`;
+    }
+    async writeLine(line) {
+        await mkdir(dirname(this.logPath), { recursive: true });
+        await appendFile(this.logPath, line, "utf8");
+        await trimLogFile(this.logPath, this.maxLines);
+    }
+}
+export const pixLogger = new PixFileLogger();
+export function logPixEvent(level, event, details) {
+    void pixLogger.log(level, event, details);
+}
+export async function trimLogFile(logPath, maxLines = PIX_LOG_MAX_LINES) {
+    const text = await readFile(logPath, "utf8").catch((error) => {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (text === undefined)
+        return;
+    const lines = text.split(/\r?\n/u);
+    if (lines.at(-1) === "")
+        lines.pop();
+    if (lines.length <= maxLines)
+        return;
+    await writeFile(logPath, `${lines.slice(-maxLines).join("\n")}\n`, "utf8");
+}
+function sanitizeToken(value) {
+    return value
+        .replace(/[\t\r\n]+/gu, " ")
+        .replace(/\s+/gu, "_")
+        .replace(/[^\w:.-]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .slice(0, 120) || "event";
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value, (_key, item) => {
+            if (item instanceof Error)
+                return { name: item.name, message: item.message, stack: item.stack };
+            if (typeof item === "bigint")
+                return item.toString();
+            return item;
+        });
+    }
+    catch (error) {
+        return JSON.stringify({ logSerializationError: error instanceof Error ? error.message : String(error) });
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/app/model/model-usage-status.js

@@ -3,7 +3,6 @@ import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { formatCompactProgressBar } from "../../context-progress-bar.js";
 const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
@@ -12,7 +11,13 @@ const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fet
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
+const PI_AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
 const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
+function getPiAuthPath() {
+    return process.env.NODE_ENV === "test" && process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+        ? process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+        : PI_AUTH_PATH;
+}
 const OPENAI_QUOTA_PROVIDERS = new Set(["openai", "openai-codex"]);
 const ZHIPU_QUOTA_PROVIDERS = new Set(["zai", "zhipuai-coding-plan"]);
 const ANTIGRAVITY_QUOTA_PROVIDERS = new Set(["antigravity", "google-antigravity"]);
@@ -245,7 +250,7 @@ async function readOpenCodeAuth() {
 }
 async function readPiAuth() {
     try {
-        const content = await readFile(join(getAgentDir(), "auth.json"), "utf8");
+        const content = await readFile(getPiAuthPath(), "utf8");
         return JSON.parse(content);
     }
     catch {
@@ -472,7 +477,7 @@ function readAllAntigravityQuotaAccounts() {
 }
 function readPiAuthSync() {
     try {
-        return JSON.parse(readFileSync(join(getAgentDir(), "auth.json"), "utf8"));
+        return JSON.parse(readFileSync(getPiAuthPath(), "utf8"));
     }
     catch {
         return {};
@@ -821,19 +826,29 @@ function maskCredential(value) {
         return visible ? "****" : "unknown";
     return `${visible.slice(0, 4)}****${visible.slice(-4)}`;
 }
-function formatUsageWindow(_prefix, window, now) {
-    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatResetCountdown(window.resetAt, now)}`;
+function formatUsageWindow(prefix, window, now) {
+    const resetLabel = prefix === "H" ? formatResetTime(window.resetAt, now) : formatGlobalResetLabel(window.resetAt, now);
+    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${resetLabel}`;
 }
-function formatResetCountdown(resetAt, now) {
+function formatGlobalResetLabel(resetAt, now) {
     if (resetAt <= now)
         return "reset";
-    const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
-    const days = Math.floor(totalMinutes / 1440);
-    const hours = Math.floor((totalMinutes % 1440) / 60);
-    const minutes = totalMinutes % 60;
-    if (days > 0)
-        return `${days}d${hours}h`;
-    if (hours > 0)
-        return `${hours}h${minutes}m`;
-    return `${minutes}m`;
+    return resetAt - now <= DAY_SECONDS * 1000 ? formatResetTime(resetAt, now) : formatResetDate(resetAt, now);
+}
+function formatResetTime(resetAt, now) {
+    if (resetAt <= now)
+        return "reset";
+    return new Date(resetAt).toLocaleTimeString("ru-RU", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    });
+}
+function formatResetDate(resetAt, now) {
+    if (resetAt <= now)
+        return "reset";
+    return new Date(resetAt).toLocaleDateString("ru-RU", {
+        day: "2-digit",
+        month: "2-digit",
+    });
 }

package/dist/app/popup/menu-items-controller.d.ts

@@ -10,6 +10,7 @@ export type AppMenuItemsControllerHost = {
 export declare class AppMenuItemsController {
     private readonly host;
     private resumeMenuLoaderCache;
+    private userMessageJumpItems;
     constructor(host: AppMenuItemsControllerHost);
     parseSlashInput(text: string): import("../types.js").ParsedSlashInput | undefined;
     getResourceSlashCommands(): SlashCommand[];
@@ -21,6 +22,7 @@ export declare class AppMenuItemsController {
     getThinkingMenuItems(query: string): PopupMenuItem<ThinkingMenuValue>[];
     getUserMessageMenuItems(): PopupMenuItem<UserMessageMenuValue>[];
     getUserMessageJumpMenuItems(query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
+    refreshUserMessageJumpMenuItems(): Promise<void>;
     getQueueMessageMenuItems(): PopupMenuItem<QueueMessageMenuValue>[];
     getResumeMenuItems(query: string, limit?: number): PopupMenuItem<ResumeMenuValue>[];
     private getResumeMenuItemsLoader;