pi-ui-extend 0.1.9 → 0.1.11

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

@@ -0,0 +1,352 @@
+import { streamSimple } from "@earendil-works/pi-ai";
+import { isRecord } from "../guards.js";
+import { parseModelRef } from "../model/model-ref.js";
+const AUTOCOMPLETE_DEBOUNCE_MS = 350;
+const AUTOCOMPLETE_MIN_TEXT_LENGTH = 3;
+const AUTOCOMPLETE_TIMEOUT_MS = 3_000;
+const AUTOCOMPLETE_MAX_TOKENS = 48;
+const AUTOCOMPLETE_MAX_PROMPT_TOKENS = 1_200;
+const AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES = 0;
+const AUTOCOMPLETE_MAX_SUFFIX_LENGTH = 320;
+const AUTOCOMPLETE_HISTORY_MESSAGE_MAX_CHARS = 700;
+const AUTOCOMPLETE_HISTORY_CONTEXT_MAX_CHARS = 3_600;
+const AUTOCOMPLETE_TOKEN_CHARS = 4;
+const AUTOCOMPLETE_SYSTEM_PROMPT = `You are an inline autocomplete engine for pix, a terminal UI for a coding agent.
+Use provided recent active-session messages only as optional context; the current draft is the source of truth.
+Continue only the user's current draft at the cursor.
+Output only the exact suffix to append after the draft.
+Do not repeat the draft. Do not answer the user. Do not explain.
+If the draft already looks complete or the continuation is uncertain, output an empty string.
+Keep the suffix short, in the user's language/style, and stop at a natural boundary.`;
+export class AppAutocompleteController {
+    host;
+    timer;
+    lastObservedKey = "";
+    requestSeq = 0;
+    suggestion;
+    activeAbortController;
+    completeInputWithPi;
+    debounceOverrideMs;
+    constructor(host, options = {}) {
+        this.host = host;
+        this.completeInputWithPi = options.completeInputWithPi ?? completeInputWithPi;
+        this.debounceOverrideMs = options.debounceMs;
+    }
+    observeInput() {
+        const target = this.currentTarget();
+        const key = target ? this.targetKey(target) : "";
+        if (key === this.lastObservedKey)
+            return;
+        this.lastObservedKey = key;
+        this.suggestion = undefined;
+        this.clearTimer();
+        this.cancelInFlight();
+        if (!target)
+            return;
+        const requestSeq = ++this.requestSeq;
+        this.timer = setTimeout(() => {
+            void this.runAutocomplete(target, requestSeq);
+        }, this.currentDebounceMs());
+        this.timer.unref?.();
+    }
+    suggestionText() {
+        const target = this.currentTarget();
+        if (!target || !this.suggestion)
+            return undefined;
+        return this.sameTarget(target, this.suggestion.target) ? this.suggestion.text : undefined;
+    }
+    acceptSuggestion() {
+        const suggestion = this.suggestionText();
+        if (!suggestion)
+            return false;
+        this.host.inputEditor().insert(suggestion);
+        this.suggestion = undefined;
+        this.lastObservedKey = "";
+        this.clearTimer();
+        this.host.render();
+        return true;
+    }
+    dispose() {
+        this.clearTimer();
+        this.cancelInFlight();
+        this.requestSeq += 1;
+        this.suggestion = undefined;
+    }
+    async runAutocomplete(target, requestSeq) {
+        const runtime = this.host.runtime();
+        const config = { ...this.host.autocompleteConfig() };
+        if (!runtime || !config.modelRef.trim())
+            return;
+        const abortController = new AbortController();
+        this.activeAbortController = abortController;
+        try {
+            const completion = await this.completeInputWithPi(runtime, target.text, config, abortController.signal);
+            if (requestSeq !== this.requestSeq)
+                return;
+            const current = this.currentTarget();
+            if (!current || !this.sameTarget(current, target))
+                return;
+            const suggestion = cleanupCompletion(completion, target.text, config);
+            if (!suggestion)
+                return;
+            this.suggestion = { target, text: suggestion };
+            if (this.host.isRunning())
+                this.host.render();
+        }
+        catch {
+            // Inline autocomplete is best-effort; avoid surfacing transient model/auth errors while typing.
+        }
+        finally {
+            if (this.activeAbortController === abortController)
+                this.activeAbortController = undefined;
+        }
+    }
+    currentTarget() {
+        const config = this.host.autocompleteConfig();
+        if (!config.modelRef.trim())
+            return undefined;
+        const editor = this.host.inputEditor();
+        const text = editor.text;
+        const cursor = editor.cursor;
+        if (editor.hasSelection || editor.hasAttachments)
+            return undefined;
+        if (cursor !== text.length)
+            return undefined;
+        if (text.trim().length < AUTOCOMPLETE_MIN_TEXT_LENGTH)
+            return undefined;
+        if (text.startsWith("/") || text.startsWith("!"))
+            return undefined;
+        return { text, cursor };
+    }
+    targetKey(target) {
+        return `${target.cursor}\u0000${target.text}`;
+    }
+    sameTarget(a, b) {
+        return a.cursor === b.cursor && a.text === b.text;
+    }
+    currentDebounceMs() {
+        return numberInRange(this.debounceOverrideMs ?? this.host.autocompleteConfig().debounceMs, AUTOCOMPLETE_DEBOUNCE_MS, 0, 5_000);
+    }
+    clearTimer() {
+        if (!this.timer)
+            return;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    cancelInFlight() {
+        this.activeAbortController?.abort();
+        this.activeAbortController = undefined;
+    }
+}
+export async function completeInputWithPi(runtime, draft, config, signal) {
+    const parsedModel = parseModelRef(config.modelRef);
+    const registry = runtime.services.modelRegistry;
+    let model = registry.find(parsedModel.provider, parsedModel.modelId);
+    if (!model) {
+        registry.refresh();
+        model = registry.find(parsedModel.provider, parsedModel.modelId);
+    }
+    if (!model)
+        throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+    const auth = await registry.getApiKeyAndHeaders(model);
+    if (!auth.ok)
+        throw new Error(auth.error);
+    const timeoutMs = numberInRange(config.timeoutMs, AUTOCOMPLETE_TIMEOUT_MS, 250, 10_000);
+    const maxTokens = numberInRange(config.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
+    const maxPromptTokens = numberInRange(config.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
+    const requestSignal = createTimeoutSignal(signal, timeoutMs);
+    const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
+    const requestModel = { ...model, maxTokens: requestMaxTokens };
+    const includeRecentMessages = numberInRange(config.includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
+    const history = includeRecentMessages > 0 ? autocompleteHistoryFromMessages(runtime.session.messages, includeRecentMessages) : [];
+    const prompt = buildAutocompletePrompt({ cwd: runtime.cwd, draft, history, maxPromptTokens });
+    if (!prompt)
+        return "";
+    let output = "";
+    let streamError;
+    try {
+        const stream = streamSimple(requestModel, {
+            systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+        }, {
+            ...(auth.apiKey === undefined ? {} : { apiKey: auth.apiKey }),
+            ...(auth.headers === undefined ? {} : { headers: auth.headers }),
+            cacheRetention: "none",
+            maxRetryDelayMs: 0,
+            maxRetries: 0,
+            maxTokens: requestModel.maxTokens,
+            ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
+            signal: requestSignal.signal,
+            temperature: 0.1,
+            timeoutMs,
+        });
+        for await (const event of stream) {
+            if (event.type === "text_delta")
+                output += event.delta;
+            else if (event.type === "done" && !output)
+                output = assistantMessageText(event.message);
+            else if (event.type === "error")
+                streamError = event.error.errorMessage ?? event.reason;
+        }
+        if (streamError)
+            throw new Error(streamError);
+        return output;
+    }
+    finally {
+        requestSignal.dispose();
+    }
+}
+export function autocompleteHistoryFromMessages(messages, includeRecentMessages) {
+    const limit = numberInRange(includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
+    if (limit <= 0)
+        return [];
+    const history = [];
+    for (let index = messages.length - 1; index >= 0 && history.length < limit; index -= 1) {
+        const message = messages[index];
+        if (!isRecord(message))
+            continue;
+        const role = message.role === "user" || message.role === "assistant" ? message.role : undefined;
+        if (!role)
+            continue;
+        const text = compactHistoryText(messageText(message, role));
+        if (!text)
+            continue;
+        history.push({ role, text: clipHistoryText(text, AUTOCOMPLETE_HISTORY_MESSAGE_MAX_CHARS) });
+    }
+    return trimHistoryContext(history.reverse(), AUTOCOMPLETE_HISTORY_CONTEXT_MAX_CHARS);
+}
+export function buildAutocompletePrompt(input) {
+    const maxPromptTokens = numberInRange(input.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
+    let history = input.history.slice();
+    let prompt = renderAutocompletePrompt({ ...input, history });
+    while (history.length > 0 && autocompletePromptTokenEstimate(prompt) > maxPromptTokens) {
+        history = history.slice(1);
+        prompt = renderAutocompletePrompt({ ...input, history });
+    }
+    return autocompletePromptTokenEstimate(prompt) <= maxPromptTokens ? prompt : "";
+}
+function renderAutocompletePrompt(input) {
+    const lines = [
+        "Complete the current terminal input for the active pix/pi coding-agent session.",
+        `cwd: ${input.cwd}`,
+    ];
+    if (input.history.length > 0) {
+        lines.push("", "Recent messages are context only; never continue them directly.", "<recent-active-session-messages>", formatAutocompleteHistory(input.history), "</recent-active-session-messages>");
+    }
+    return [
+        ...lines,
+        "",
+        "Return only the suffix to append after <cursor>. Return nothing if unsure.",
+        "<draft>",
+        input.draft,
+        "<cursor>",
+        "</draft>",
+    ].join("\n");
+}
+export function autocompletePromptTokenEstimate(prompt, systemPrompt = AUTOCOMPLETE_SYSTEM_PROMPT) {
+    return estimateTextTokens(systemPrompt) + estimateTextTokens(prompt);
+}
+function estimateTextTokens(text) {
+    return Math.ceil(text.length / AUTOCOMPLETE_TOKEN_CHARS);
+}
+export function cleanupCompletion(output, draft, config) {
+    let text = output.replace(/\r\n/gu, "\n").trimEnd();
+    const fenced = /^```[^\n`]*\n([\s\S]*?)\n```$/u.exec(text.trim());
+    if (fenced)
+        text = fenced[1].trimEnd();
+    if (text.startsWith(draft))
+        text = text.slice(draft.length);
+    text = text
+        .replace(/^<cursor>/iu, "")
+        .replace(/^\s*(?:completion|suffix|autocomplete|продолжение)\s*:\s*/iu, "")
+        .replace(/^\n+/u, "");
+    if (!text.trim())
+        return "";
+    const maxTokens = numberInRange(config?.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
+    const maxChars = Math.min(AUTOCOMPLETE_MAX_SUFFIX_LENGTH, maxTokens * 8);
+    return text.slice(0, maxChars);
+}
+function formatAutocompleteHistory(history) {
+    if (history.length === 0)
+        return "(no previous user/assistant messages in this active session)";
+    return history.map((message) => [
+        `<message role="${message.role}">`,
+        message.text.replace(/<\/message>/giu, "</ message>"),
+        "</message>",
+    ].join("\n")).join("\n\n");
+}
+function assistantMessageText(message) {
+    return message.content
+        .flatMap((content) => content.type === "text" ? [content.text] : [])
+        .join("\n");
+}
+function messageText(message, role) {
+    return contentText(message.content, { includeImages: role === "user" });
+}
+function contentText(content, options) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => {
+        if (!isRecord(part) || typeof part.type !== "string")
+            return [];
+        if (part.type === "text" && typeof part.text === "string")
+            return [part.text];
+        if (part.type === "image" && options.includeImages)
+            return ["[image]"];
+        return [];
+    }).join("\n");
+}
+function compactHistoryText(text) {
+    return text
+        .replace(/\r\n/gu, "\n")
+        .split("\n")
+        .filter((line) => !isMarkdownReferenceDefinition(line))
+        .join("\n")
+        .replace(/[\t ]+/gu, " ")
+        .replace(/\n{3,}/gu, "\n\n")
+        .trim();
+}
+function clipHistoryText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const headLength = Math.floor((maxChars - 3) / 2);
+    const tailLength = maxChars - 3 - headLength;
+    return `${text.slice(0, headLength).trimEnd()}\n…\n${text.slice(-tailLength).trimStart()}`;
+}
+function trimHistoryContext(history, maxChars) {
+    const trimmed = history.slice();
+    while (trimmed.length > 0 && historyContextChars(trimmed) > maxChars)
+        trimmed.shift();
+    return trimmed;
+}
+function historyContextChars(history) {
+    return history.reduce((sum, message) => sum + message.text.length + message.role.length + 32, 0);
+}
+function isMarkdownReferenceDefinition(line) {
+    return /^ {0,3}\[[^\]\n]+\]:[ \t]*\S.*$/u.test(line);
+}
+function numberInRange(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const rounded = Math.round(value);
+    return Math.min(max, Math.max(min, rounded));
+}
+function createTimeoutSignal(parent, timeoutMs) {
+    const abortController = new AbortController();
+    const abort = () => abortController.abort();
+    if (parent?.aborted)
+        abort();
+    else
+        parent?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(abort, timeoutMs);
+    timer.unref?.();
+    return {
+        signal: abortController.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener("abort", abort);
+        },
+    };
+}

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

@@ -36,6 +36,7 @@ export declare class AppInputActionController {
     private abortInFlight;
     constructor(host: AppInputActionControllerHost, popupMenus: AppPopupMenuController, popupActions: AppPopupActionController, queuedMessages: AppQueuedMessageController);
     handleEnter(): void;
+    queueInputFromEditor(): Promise<void>;
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
     private abortStreamingSession;

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

@@ -21,6 +21,27 @@ export class AppInputActionController {
         }
         void this.submitInput();
     }
+    async queueInputFromEditor() {
+        await this.host.stopVoiceInput();
+        if (this.popupMenus.syncActivePopupMenu())
+            this.popupMenus.cancelActivePopupMenu();
+        const inputEditor = this.host.inputEditor();
+        const rawPromptText = inputEditor.promptText;
+        const rawDisplayText = inputEditor.expandedText;
+        const promptText = rawPromptText.trimEnd();
+        const displayText = rawDisplayText.trimEnd();
+        const images = [...inputEditor.images];
+        if (!promptText && images.length === 0)
+            return;
+        const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
+        this.host.requestHistory().add(message.displayText);
+        inputEditor.clear();
+        await this.host.clearPersistedInputDraft();
+        this.host.render();
+        this.queuedMessages.deferUserMessage(message);
+        if (this.host.isRunning())
+            this.host.render();
+    }
     async handleInterrupt() {
         if (this.host.interruptShellCommand()) {
             this.host.inputEditor().clear();

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

@@ -24,6 +24,7 @@ export type InputControllerHost = {
     handleDirectPopupInput(char: string): boolean;
     autocompleteModel(): boolean;
     autocompleteThinking(): boolean;
+    acceptAutocompleteSuggestion(): boolean;
     autocompleteSlashCommand(): void;
     toggleVoiceRecording(): void;
     stop(): Promise<void>;

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

@@ -357,6 +357,8 @@ export class AppInputController {
         if (char === "\t") {
             if (this.host.getDirectPopupMenu() === "sdk-menu")
                 return;
+            if (this.host.acceptAutocompleteSuggestion())
+                return;
             if (this.host.autocompleteModel())
                 return;
             if (this.host.autocompleteThinking())

package/dist/app/input/input-paste-handler.d.ts

@@ -20,6 +20,7 @@ export declare class InputPasteHandler {
     private plainPasteFilePath;
     private isDuplicatePaste;
     private handlePasteEnd;
+    private schedulePastedText;
     private handleFilePaste;
     private filePathForInput;
     private displayPathForInput;

package/dist/app/input/input-paste-handler.js

@@ -4,6 +4,7 @@ import { isAbsolute, relative, resolve } from "node:path";
 import { isImagePath, looksLikeFilePath, quoteFilePathForInput, readClipboardImage } from "../../input-editor.js";
 import { PASTE_DUPLICATE_WINDOW_MS } from "../constants.js";
 import { normalizePastedTextForDuplicateKey } from "../rendering/render-text.js";
+const PASTE_FINGERPRINT_PREFIX_CHARS = 64 * 1024;
 export class InputPasteHandler {
     host;
     pasteBuffer = "";
@@ -23,13 +24,7 @@ export class InputPasteHandler {
             return true;
         }
         if (!this.host.inputEditor.isInBracketedPaste && this.isPlainMultilinePasteChunk(data)) {
-            if (this.isDuplicatePaste("text", data)) {
-                this.host.render();
-                return true;
-            }
-            this.host.resetRequestHistoryNavigation();
-            this.host.inputEditor.attachPastedText(data);
-            this.host.render();
+            this.schedulePastedText(data);
             return true;
         }
         return false;
@@ -43,7 +38,9 @@ export class InputPasteHandler {
     }
     endBracketedPaste() {
         this.host.inputEditor.endBracketedPaste();
-        this.handlePasteEnd();
+        const text = this.pasteBuffer;
+        this.pasteBuffer = "";
+        this.handlePasteEnd(text);
     }
     async handleClipboardImagePaste() {
         const image = await readClipboardImage();
@@ -83,16 +80,17 @@ export class InputPasteHandler {
                 this.recentPasteFingerprints.delete(fingerprint);
         }
         const normalizedPayload = kind === "text" ? normalizePastedTextForDuplicateKey(payload) : payload;
-        const fingerprint = `${kind}:${createHash("sha256").update(normalizedPayload).digest("hex")}`;
+        const fingerprintPayload = normalizedPayload.length > PASTE_FINGERPRINT_PREFIX_CHARS
+            ? `${normalizedPayload.length}:${normalizedPayload.slice(0, PASTE_FINGERPRINT_PREFIX_CHARS)}`
+            : normalizedPayload;
+        const fingerprint = `${kind}:${createHash("sha256").update(fingerprintPayload).digest("hex")}`;
         const previousTimestamp = this.recentPasteFingerprints.get(fingerprint);
         if (previousTimestamp !== undefined && now - previousTimestamp <= PASTE_DUPLICATE_WINDOW_MS)
             return true;
         this.recentPasteFingerprints.set(fingerprint, now);
         return false;
     }
-    handlePasteEnd() {
-        const text = this.pasteBuffer;
-        this.pasteBuffer = "";
+    handlePasteEnd(text) {
         if (!text)
             return;
         const filePath = this.plainPasteFilePath(text);
@@ -104,13 +102,19 @@ export class InputPasteHandler {
             void this.handleFilePaste(filePath);
             return;
         }
-        if (this.isDuplicatePaste("text", text)) {
+        this.schedulePastedText(text);
+    }
+    schedulePastedText(text) {
+        const timer = setTimeout(() => {
+            if (this.isDuplicatePaste("text", text)) {
+                this.host.render();
+                return;
+            }
+            this.host.resetRequestHistoryNavigation();
+            this.host.inputEditor.attachPastedText(text);
             this.host.render();
-            return;
-        }
-        this.host.resetRequestHistoryNavigation();
-        this.host.inputEditor.attachPastedText(text);
-        this.host.render();
+        }, 0);
+        timer.unref?.();
     }
     async handleFilePaste(filePath) {
         const inputPath = await this.filePathForInput(filePath);

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

@@ -22,6 +22,7 @@ export declare class AppVoiceController {
     private progressTimer;
     private lastSystemProgressMessage;
     private partialTranscript;
+    private partialTranscriptTimer;
     private startGeneration;
     constructor(host: AppVoiceControllerHost, dictationConfig: DictationConfig);
     statusWidgetText(): string;
@@ -47,6 +48,7 @@ export declare class AppVoiceController {
     private emitTranscript;
     private emitPartialTranscript;
     private clearPartialTranscript;
+    private schedulePartialTranscriptEmit;
     private isCurrentStart;
     private isCurrentAudioProcess;
 }

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

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import http from "node:http";
@@ -8,12 +8,14 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { savePixDictationLanguage } from "../../config.js";
 import { APP_ICONS } from "../icons.js";
+import { commandExists } from "../process.js";
 const SAMPLE_RATE = 16_000;
 const require = createRequire(import.meta.url);
 const projectRoot = fileURLToPath(new URL("../..", import.meta.url));
 const modelsRoot = join(projectRoot, "models", "vosk");
 const VOSK_PACKAGE_SPEC = "vosk@0.3.39";
 const VOICE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS = 100;
 let voskInstallPromise;
 export class AppVoiceController {
     host;
@@ -29,6 +31,7 @@ export class AppVoiceController {
     progressTimer;
     lastSystemProgressMessage;
     partialTranscript;
+    partialTranscriptTimer;
     startGeneration = 0;
     constructor(host, dictationConfig) {
         this.host = host;
@@ -128,7 +131,7 @@ export class AppVoiceController {
             this.state = "loading";
             this.host.render();
             const model = this.cachedModel(language, modelPath, vosk);
-            const recorder = selectRecorderCommand();
+            const recorder = await selectRecorderCommand();
             const recognizer = new vosk.Recognizer({ model, sampleRate: SAMPLE_RATE });
             const audioProcess = spawn(recorder.command, recorder.args, { stdio: ["ignore", "pipe", "pipe"] });
             this.recognizer = recognizer;
@@ -283,14 +286,27 @@ export class AppVoiceController {
         if (text === this.partialTranscript)
             return;
         this.partialTranscript = text;
-        this.host.setPartialTranscript(text);
+        this.schedulePartialTranscriptEmit();
     }
     clearPartialTranscript() {
         if (!this.partialTranscript)
             return;
         this.partialTranscript = undefined;
+        if (this.partialTranscriptTimer) {
+            clearTimeout(this.partialTranscriptTimer);
+            this.partialTranscriptTimer = undefined;
+        }
         this.host.setPartialTranscript(undefined);
     }
+    schedulePartialTranscriptEmit() {
+        if (this.partialTranscriptTimer)
+            return;
+        this.partialTranscriptTimer = setTimeout(() => {
+            this.partialTranscriptTimer = undefined;
+            this.host.setPartialTranscript(this.partialTranscript);
+        }, VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS);
+        this.partialTranscriptTimer.unref?.();
+    }
     isCurrentStart(generation) {
         return this.startGeneration === generation;
     }
@@ -367,11 +383,11 @@ async function downloadFile(url, destination, redirects = 3) {
     });
 }
 async function extractZip(zipPath, destination) {
-    if (commandExists("unzip")) {
+    if (await commandExists("unzip")) {
         await runCommand("unzip", ["-q", zipPath, "-d", destination]);
         return;
     }
-    if (process.platform === "darwin" && commandExists("ditto")) {
+    if (process.platform === "darwin" && await commandExists("ditto")) {
         await runCommand("ditto", ["-x", "-k", zipPath, destination]);
         return;
     }
@@ -535,7 +551,7 @@ function isVoskModule(value) {
     const record = value;
     return typeof record.Model === "function" && typeof record.Recognizer === "function";
 }
-function selectRecorderCommand() {
+async function selectRecorderCommand() {
     const commands = [
         {
             command: "rec",
@@ -566,15 +582,11 @@ function selectRecorderCommand() {
             description: "arecord",
         });
     }
-    const command = commands.find((candidate) => commandExists(candidate.command));
-    if (!command)
-        throw new Error("audio recorder not found: install SoX (`rec`/`sox`), ffmpeg, or arecord");
-    return command;
-}
-function commandExists(command) {
-    if (process.platform === "win32")
-        return spawnSync("where", [command], { stdio: "ignore" }).status === 0;
-    return spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" }).status === 0;
+    for (const candidate of commands) {
+        if (await commandExists(candidate.command))
+            return candidate;
+    }
+    throw new Error("audio recorder not found: install SoX (`rec`/`sox`), ffmpeg, or arecord");
 }
 function transcriptText(result) {
     const parsed = typeof result === "string" ? parseResultString(result) : result;

package/dist/app/model/model-usage-status.d.ts

@@ -79,9 +79,18 @@ export type OpenAIUsageResponse = {
     rate_limit: OpenAIRateLimit | null;
     additional_rate_limits?: OpenAIAdditionalRateLimit[];
 };
+type AntigravityCachedQuotaBucket = {
+    remainingFraction?: number;
+    resetTime?: string;
+    modelCount?: number;
+};
+type AntigravityCachedQuota = Record<string, AntigravityCachedQuotaBucket | undefined>;
 type AntigravityQuotaAccount = {
     readonly email?: string;
     readonly refreshToken: string;
+    readonly accessToken?: string;
+    readonly cachedQuota?: AntigravityCachedQuota;
+    readonly cachedQuotaUpdatedAt?: number;
     readonly projectId: string;
     readonly accountIndex?: number;
     readonly accountCount?: number;