pi-ui-extend 0.1.8 → 0.1.11

package/dist/app/{voice-controller.js → 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";
@@ -6,14 +6,16 @@ import https from "node:https";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { savePixDictationLanguage } from "../config.js";
-import { APP_ICONS } from "./icons.js";
+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-ref.d.ts → model/model-ref.d.ts}

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "./types.js";
+import type { ThinkingLevel } from "../types.js";
 export declare function parseModelRef(value: string): {
     provider: string;
     modelId: string;

package/dist/app/{model-ref.js → model/model-ref.js}

@@ -1,4 +1,4 @@
-import { THINKING_LEVELS } from "./constants.js";
+import { THINKING_LEVELS } from "../constants.js";
 export function parseModelRef(value) {
     const [modelPart, thinkingPart] = value.split(":", 2);
     if (!modelPart)

package/dist/app/{model-usage-controller.js → model/model-usage-controller.js}

@@ -1,4 +1,4 @@
-import { MODEL_USAGE_POLL_INTERVAL_MS, MODEL_USAGE_STATUS_TICK_MS } from "./constants.js";
+import { MODEL_USAGE_POLL_INTERVAL_MS, MODEL_USAGE_STATUS_TICK_MS } from "../constants.js";
 import { formatModelUsageStatusLabel, modelUsageDescriptor, queryModelUsageStatus, } from "./model-usage-status.js";
 export class AppModelUsageController {
     host;

package/dist/app/{model-usage-status.d.ts → model/model-usage-status.d.ts}

@@ -1,4 +1,4 @@
-import type { SessionModel } from "./types.js";
+import type { SessionModel } from "../types.js";
 type BaseModelUsageDescriptor = {
     readonly modelKey: string;
 };
@@ -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;

package/dist/app/{model-usage-status.js → model/model-usage-status.js}

@@ -4,18 +4,15 @@ 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";
+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";
 const ZHIPU_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
 const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
-const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
 const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
-const GOOGLE_CLIENT_ID = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_ID ?? "";
-const GOOGLE_CLIENT_SECRET = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? "";
 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"]);
@@ -401,8 +398,13 @@ export function googleAntigravityUsageStatusFromResponse(data, descriptor, now =
     };
 }
 async function queryGoogleAntigravityModelUsage(descriptor) {
-    const { access_token } = await refreshGoogleAccessToken(descriptor.account.refreshToken);
-    const response = await fetchGoogleAntigravityQuota(access_token, descriptor.account.projectId);
+    const now = Date.now();
+    const cachedResponse = googleQuotaResponseFromCachedQuota(descriptor.account.cachedQuota, descriptor.account.cachedQuotaUpdatedAt, now);
+    if (cachedResponse)
+        return googleAntigravityUsageStatusFromResponse(cachedResponse, descriptor, now);
+    if (!descriptor.account.accessToken)
+        return undefined;
+    const response = await fetchGoogleAntigravityQuota(descriptor.account.accessToken, descriptor.account.projectId);
     return googleAntigravityUsageStatusFromResponse(response, descriptor);
 }
 const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
@@ -417,10 +419,12 @@ async function queryGoogleAntigravityAccountUsage(now) {
     const results = await Promise.all(accounts.map(async (account) => {
         const accountLabel = account.email ?? maskCredential(account.refreshToken);
         try {
-            const { access_token } = await refreshGoogleAccessToken(account.refreshToken);
-            const response = await fetchGoogleAntigravityQuota(access_token, account.projectId);
-            const windows = GOOGLE_ACCOUNT_QUOTA_WINDOWS.map((window) => googleAccountWindowFromResponse(response, window.label, window.quotaModelKey, now))
-                .filter((window) => window !== undefined);
+            const response = account.cachedQuota ? googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now) : undefined;
+            const windows = response ? googleAccountWindowsFromResponse(response, now) : [];
+            if (windows.length === 0 && account.accessToken) {
+                const liveResponse = await fetchGoogleAntigravityQuota(account.accessToken, account.projectId);
+                windows.push(...googleAccountWindowsFromResponse(liveResponse, now));
+            }
             return {
                 account: accountLabel,
                 windows,
@@ -449,15 +453,20 @@ function readAllAntigravityQuotaAccounts() {
         return [];
     const accounts = storedAntigravityAccounts(credential);
     if (accounts.length > 0) {
+        const activeIndex = clampAccountIndex(credential.activeIndex, accounts.length);
+        const activeAccess = antigravityAccessFromCredential(credential);
         return accounts.map((account, accountIndex) => antigravityQuotaAccount(account, {
             ...(credential.email ? { fallbackEmail: credential.email } : {}),
+            ...(accountIndex === activeIndex && activeAccess ? { accessToken: activeAccess.accessToken } : {}),
             accountIndex,
             accountCount: accounts.length,
         })).filter((account) => account !== undefined);
     }
     const fallbackAccount = antigravityAccountFromCredential(credential);
+    const fallbackAccess = antigravityAccessFromCredential(credential);
     const account = fallbackAccount ? antigravityQuotaAccount(fallbackAccount, {
         ...(credential.email ? { fallbackEmail: credential.email } : {}),
+        ...(fallbackAccess ? { accessToken: fallbackAccess.accessToken } : {}),
     }) : undefined;
     return account ? [account] : [];
 }
@@ -480,12 +489,15 @@ function antigravityAccountFromCredential(credential) {
     const refresh = splitAntigravityRefresh(credential.refresh);
     if (!refresh.refreshToken)
         return undefined;
+    const activeStoredAccount = credential.accounts?.[clampAccountIndex(credential.activeIndex, credential.accounts.length)];
     return {
         refreshToken: refresh.refreshToken,
         projectId: refresh.projectId || refresh.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID,
         enabled: true,
         ...(credential.email ? { email: credential.email } : {}),
         ...(refresh.managedProjectId ? { managedProjectId: refresh.managedProjectId } : {}),
+        ...(activeStoredAccount?.cachedQuota ? { cachedQuota: activeStoredAccount.cachedQuota } : {}),
+        ...(typeof activeStoredAccount?.cachedQuotaUpdatedAt === "number" ? { cachedQuotaUpdatedAt: activeStoredAccount.cachedQuotaUpdatedAt } : {}),
     };
 }
 function antigravityQuotaAccount(account, options = {}) {
@@ -498,11 +510,65 @@ function antigravityQuotaAccount(account, options = {}) {
         refreshToken,
         projectId,
         cacheKey: email ? email.toLowerCase() : shortHash(refreshToken),
+        ...(options.accessToken ? { accessToken: options.accessToken } : {}),
+        ...(account.cachedQuota ? { cachedQuota: account.cachedQuota } : {}),
+        ...(typeof account.cachedQuotaUpdatedAt === "number" ? { cachedQuotaUpdatedAt: account.cachedQuotaUpdatedAt } : {}),
         ...(email ? { email } : {}),
         ...(typeof options.accountIndex === "number" ? { accountIndex: options.accountIndex } : {}),
         ...(typeof options.accountCount === "number" ? { accountCount: options.accountCount } : {}),
     };
 }
+function googleQuotaResponseFromCachedQuota(cachedQuota, cachedQuotaUpdatedAt, now = Date.now()) {
+    if (!cachedQuota)
+        return undefined;
+    const models = {};
+    addCachedQuotaModels(models, cachedQuota.claude, ["claude-opus-4-6-thinking", "claude-sonnet-4-6"], cachedQuotaUpdatedAt, now);
+    addCachedQuotaModels(models, cachedQuota["gemini-flash"], ["gemini-2.5-flash", "gemini-3-flash"], cachedQuotaUpdatedAt, now);
+    addCachedQuotaModels(models, cachedQuota["gemini-pro"], ["gemini-3.1-pro-low"], cachedQuotaUpdatedAt, now);
+    return Object.keys(models).length > 0 ? { models } : undefined;
+}
+function addCachedQuotaModels(models, quota, quotaModelKeys, cachedQuotaUpdatedAt, now) {
+    if (!quota || !Number.isFinite(quota.remainingFraction))
+        return;
+    const remainingFraction = quota.remainingFraction;
+    const resetTime = cachedQuotaResetTimeForDisplay(quota.resetTime, cachedQuotaUpdatedAt, now);
+    for (const quotaModelKey of quotaModelKeys) {
+        models[quotaModelKey] = {
+            quotaInfo: {
+                remainingFraction,
+                ...(resetTime ? { resetTime } : {}),
+            },
+        };
+    }
+}
+function cachedQuotaResetTimeForDisplay(resetTime, cachedQuotaUpdatedAt, now) {
+    if (!resetTime)
+        return undefined;
+    const resetAt = Date.parse(resetTime);
+    if (!Number.isFinite(resetAt) || resetAt > now)
+        return resetTime;
+    const cachedAt = normalizeTimestampMillis(cachedQuotaUpdatedAt);
+    if (!Number.isFinite(cachedAt) || resetAt <= cachedAt)
+        return resetTime;
+    return new Date(now + (resetAt - cachedAt)).toISOString();
+}
+function normalizeTimestampMillis(value) {
+    if (!Number.isFinite(value))
+        return Number.NaN;
+    const timestamp = value;
+    return timestamp < 1_000_000_000_000 ? timestamp * 1000 : timestamp;
+}
+function antigravityAccessFromCredential(credential) {
+    if (credential.type !== "oauth" || !credential.access || isExpired(credential))
+        return undefined;
+    const [accessToken = "", projectId = ""] = credential.access.split("|");
+    if (!accessToken)
+        return undefined;
+    return {
+        accessToken,
+        ...(projectId ? { projectId } : {}),
+    };
+}
 function splitAntigravityRefresh(refresh) {
     const [refreshToken = "", projectId = "", managedProjectId = ""] = refresh.split("|");
     return {
@@ -519,26 +585,6 @@ function clampAccountIndex(index, accountCount) {
 function shortHash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
-async function refreshGoogleAccessToken(refreshToken) {
-    if (!GOOGLE_CLIENT_ID || !GOOGLE_CLIENT_SECRET) {
-        throw new Error("Antigravity Google OAuth credentials are not configured; set PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID and PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET.");
-    }
-    const response = await fetchWithTimeout(GOOGLE_TOKEN_REFRESH_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-            client_id: GOOGLE_CLIENT_ID,
-            client_secret: GOOGLE_CLIENT_SECRET,
-            refresh_token: refreshToken,
-            grant_type: "refresh_token",
-        }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Google token refresh failed (${response.status}): ${errorText}`);
-    }
-    return response.json();
-}
 async function fetchGoogleAntigravityQuota(accessToken, projectId) {
     const response = await fetchWithTimeout(GOOGLE_QUOTA_API_URL, {
         method: "POST",
@@ -633,18 +679,51 @@ function selectOpenAIRateLimitForModel(data, modelKey) {
             return false;
         return openAIModelMatchesAdditionalLimit(modelKey, limit);
     });
+    // Prefer exact named per-model buckets when the API exposes them, but keep the
+    // top-level bucket as a fallback. Some Codex responses currently expose a
+    // usable selected-model/account bucket only at the top level while also
+    // listing unrelated named additional buckets; hiding the fallback makes the
+    // status bar disappear completely for those models.
     return additionalLimit?.rate_limit ?? data.rate_limit;
 }
 function openAIModelMatchesAdditionalLimit(modelKey, limit) {
-    const normalizedModel = normalizeOpenAILimitName(modelKey.split("/").at(-1) ?? modelKey);
-    const normalizedLimitName = normalizeOpenAILimitName(limit.limit_name);
-    const normalizedMeteredFeature = limit.metered_feature ? normalizeOpenAILimitName(limit.metered_feature) : "";
-    return (!!normalizedLimitName && (normalizedModel.includes(normalizedLimitName) || normalizedLimitName.includes(normalizedModel)))
-        || (!!normalizedMeteredFeature && (normalizedModel.includes(normalizedMeteredFeature) || normalizedMeteredFeature.includes(normalizedModel)));
+    const modelId = modelKey.split("/").at(-1) ?? modelKey;
+    return openAIModelIdMatchesLimitCandidate(modelId, limit.limit_name)
+        || (limit.metered_feature ? openAIModelIdMatchesLimitCandidate(modelId, limit.metered_feature) : false);
+}
+function openAIModelIdMatchesLimitCandidate(modelId, candidate) {
+    const modelTokens = openAILimitTokens(modelId);
+    const candidateTokens = openAILimitTokens(candidate);
+    if (modelTokens.length === 0 || candidateTokens.length === 0)
+        return false;
+    if (containsTokenSequence(candidateTokens, modelTokens))
+        return true;
+    // Support compact names such as o4mini while avoiding prefix matches such as
+    // gpt-5 accidentally matching gpt-5.5.
+    return normalizeOpenAILimitName(candidate) === normalizeOpenAILimitName(modelId);
 }
 function normalizeOpenAILimitName(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/gu, "");
 }
+function openAILimitTokens(value) {
+    return value.toLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 0);
+}
+function containsTokenSequence(tokens, sequence) {
+    if (sequence.length > tokens.length)
+        return false;
+    for (let start = 0; start <= tokens.length - sequence.length; start += 1) {
+        let matches = true;
+        for (let offset = 0; offset < sequence.length; offset += 1) {
+            if (tokens[start + offset] !== sequence[offset]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return true;
+    }
+    return false;
+}
 function selectWeeklyWindow(windows) {
     return windows
         .filter((window) => window.limit_window_seconds >= 6 * DAY_SECONDS)
@@ -683,6 +762,11 @@ function googleAccountWindowFromResponse(data, label, quotaModelKey, now) {
         windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
     };
 }
+function googleAccountWindowsFromResponse(data, now) {
+    return GOOGLE_ACCOUNT_QUOTA_WINDOWS
+        .map((window) => googleAccountWindowFromResponse(data, window.label, window.quotaModelKey, now))
+        .filter((window) => window !== undefined);
+}
 function clampPercent(percent) {
     return Math.max(0, Math.min(100, percent));
 }
@@ -706,6 +790,8 @@ function formatQuotaBar(percent, width) {
     return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
 }
 function formatDurationLong(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);
@@ -717,6 +803,8 @@ function formatDurationLong(resetAt, now) {
     return `${minutes}m`;
 }
 function formatDurationShort(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);
@@ -737,6 +825,8 @@ function formatUsageWindow(_prefix, window, now) {
     return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatResetCountdown(window.resetAt, now)}`;
 }
 function formatResetCountdown(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);

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

@@ -1,6 +1,6 @@
 import type { AgentSessionRuntime, SessionInfo } from "@earendil-works/pi-coding-agent";
-import type { PopupMenuItem } from "../ui.js";
-import type { Entry, ModelMenuValue, QueueMessageMenuValue, ResumeMenuValue, ScopedSessionModel, SessionModel, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "./types.js";
+import type { PopupMenuItem } from "../../ui.js";
+import type { Entry, ModelMenuValue, QueueMessageMenuValue, ResumeMenuValue, ScopedSessionModel, SessionModel, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
 export type AppMenuItemsControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     getBuiltinSlashCommands(): readonly SlashCommand[];
@@ -11,9 +11,9 @@ export declare class AppMenuItemsController {
     private readonly host;
     private resumeMenuLoaderCache;
     constructor(host: AppMenuItemsControllerHost);
-    parseSlashInput(text: string): import("./types.js").ParsedSlashInput | undefined;
+    parseSlashInput(text: string): import("../types.js").ParsedSlashInput | undefined;
     getResourceSlashCommands(): SlashCommand[];
-    getSlashCommandMatches(query: string, limit?: number): import("../fuzzy.js").FuzzyMatch<SlashCommand>[];
+    getSlashCommandMatches(query: string, limit?: number): import("../../fuzzy.js").FuzzyMatch<SlashCommand>[];
     getSlashCommandMenuItems(query: string): PopupMenuItem<SlashCommand>[];
     modelRef(model: SessionModel): string;
     getFavoriteScopedModels(): ScopedSessionModel[];

package/dist/app/{menu-items-controller.js → popup/menu-items-controller.js}

@@ -1,10 +1,10 @@
 import { resolve } from "node:path";
-import { fuzzySearch } from "../fuzzy.js";
-import { PI_FAVORITE_MODEL_REFS, THINKING_LEVELS } from "./constants.js";
-import { APP_ICONS } from "./icons.js";
-import { parseScopedModelRef } from "./model-ref.js";
+import { fuzzySearch } from "../../fuzzy.js";
+import { PI_FAVORITE_MODEL_REFS, THINKING_LEVELS } from "../constants.js";
+import { APP_ICONS } from "../icons.js";
+import { parseScopedModelRef } from "../model/model-ref.js";
 import { buildUserMessageJumpItems, createSessionInfoMenuItemsLoader } from "./popup-menu-controller.js";
-import { getResourceSlashCommands, getSlashCommandMatches, parseSlashInput } from "./slash-commands.js";
+import { getResourceSlashCommands, getSlashCommandMatches, parseSlashInput } from "../commands/slash-commands.js";
 export class AppMenuItemsController {
     host;
     resumeMenuLoaderCache;

package/dist/app/{popup-action-controller.d.ts → popup/popup-action-controller.d.ts}

@@ -1,10 +1,10 @@
 import type { AgentSession, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { AppCommandController } from "./command-controller.js";
+import type { AppCommandController } from "../commands/command-controller.js";
 import type { AppMenuItemsController } from "./menu-items-controller.js";
 import type { AppPopupMenuController } from "./popup-menu-controller.js";
-import type { AppQueuedMessageController } from "./queued-message-controller.js";
-import type { Entry, SlashCommand } from "./types.js";
-import type { AppWorkspaceActionsController } from "./workspace-actions-controller.js";
+import type { AppQueuedMessageController } from "../session/queued-message-controller.js";
+import type { Entry, SlashCommand } from "../types.js";
+import type { AppWorkspaceActionsController } from "../workspace/workspace-actions-controller.js";
 export type AppPopupActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     getBuiltinSlashCommands(): readonly SlashCommand[];

package/dist/app/{popup-action-controller.js → popup/popup-action-controller.js}

@@ -1,5 +1,5 @@
-import { createId } from "./id.js";
-import { stringifyUnknown } from "./message-content.js";
+import { createId } from "../id.js";
+import { stringifyUnknown } from "../rendering/message-content.js";
 export class AppPopupActionController {
     host;
     popupMenus;
@@ -148,7 +148,7 @@ export class AppPopupActionController {
         this.host.render();
         try {
             if (selected.value === "copy") {
-                this.workspaceActions.copyUserMessage(selected.entryId);
+                await this.workspaceActions.copyUserMessage(selected.entryId);
                 return true;
             }
             if (selected.value === "fork") {

package/dist/app/{popup-menu-controller.d.ts → popup/popup-menu-controller.d.ts}

@@ -1,7 +1,7 @@
-import { type Theme } from "../theme.js";
-import { PopupMenu, type PopupMenuItem } from "../ui.js";
-import type { ScreenStyler } from "./screen-styler.js";
-import type { ActivePopupMenu, Entry, ModelMenuValue, ParsedSlashInput, PixMenuController, PixMenuItem, PixMenuOptions, PixMenuSelectOptions, PopupMenuPlacement, QueueMessageMenuValue, RenderedLine, ResumeMenuValue, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "./types.js";
+import { type Theme } from "../../theme.js";
+import { PopupMenu, type PopupMenuItem } from "../../ui.js";
+import type { ScreenStyler } from "../screen/screen-styler.js";
+import type { ActivePopupMenu, Entry, ModelMenuValue, ParsedSlashInput, PixMenuController, PixMenuItem, PixMenuOptions, PixMenuSelectOptions, PopupMenuPlacement, QueueMessageMenuValue, RenderedLine, ResumeMenuValue, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
 import type { AgentSession, SessionInfo } from "@earendil-works/pi-coding-agent";
 type SlashCommandMenuValue = SlashCommand;
 type ModelPopupMenuValue = ModelMenuValue;

package/dist/app/{popup-menu-controller.js → popup/popup-menu-controller.js}

@@ -1,11 +1,11 @@
 import { resolve } from "node:path";
-import { fuzzySearch } from "../fuzzy.js";
-import { colorLine } from "../theme.js";
-import { PopupMenu } from "../ui.js";
-import { padOrTrimPlain, ellipsizeDisplay, sanitizeText } from "./render-text.js";
-import { stringDisplayWidth } from "../terminal-width.js";
-import { RESUME_MENU_INITIAL_SESSION_ROWS, RESUME_MENU_LOAD_BATCH_ROWS, RESUME_MENU_LOAD_THRESHOLD_ROWS, RESUME_MENU_MAX_ROWS, SLASH_COMMAND_DESCRIPTION_COLUMN, SLASH_COMMAND_MENU_MAX_ROWS, THINKING_MENU_MAX_ROWS, } from "./constants.js";
-import { APP_ICONS } from "./icons.js";
+import { fuzzySearch } from "../../fuzzy.js";
+import { colorLine } from "../../theme.js";
+import { PopupMenu } from "../../ui.js";
+import { padOrTrimPlain, ellipsizeDisplay, sanitizeText } from "../rendering/render-text.js";
+import { stringDisplayWidth } from "../../terminal-width.js";
+import { RESUME_MENU_INITIAL_SESSION_ROWS, RESUME_MENU_LOAD_BATCH_ROWS, RESUME_MENU_LOAD_THRESHOLD_ROWS, RESUME_MENU_MAX_ROWS, SLASH_COMMAND_DESCRIPTION_COLUMN, SLASH_COMMAND_MENU_MAX_ROWS, THINKING_MENU_MAX_ROWS, } from "../constants.js";
+import { APP_ICONS } from "../icons.js";
 const POPUP_MENU_ESCAPE_BUTTON = "Esc";
 export class AppPopupMenuController {
     host;

package/dist/app/process.d.ts

@@ -0,0 +1,17 @@
+export type AsyncProcessResult = {
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+    timedOut?: boolean;
+};
+export type RunProcessOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string;
+    timeoutMs?: number;
+    maxBufferBytes?: number;
+};
+export declare function runProcess(command: string, args?: readonly string[], options?: RunProcessOptions): Promise<AsyncProcessResult>;
+export declare function commandExists(command: string, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/app/process.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+const DEFAULT_MAX_BUFFER_BYTES = 1024 * 1024;
+export async function runProcess(command, args = [], options = {}) {
+    const maxBufferBytes = Math.max(1, options.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES);
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let error;
+        let timedOut = false;
+        const child = spawn(command, [...args], {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const append = (current, chunk) => {
+            const next = `${current}${chunk.toString("utf8")}`;
+            return next.length > maxBufferBytes ? next.slice(-maxBufferBytes) : next;
+        };
+        const timer = options.timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, options.timeoutMs);
+        timer?.unref?.();
+        child.stdout.on("data", (chunk) => {
+            stdout = append(stdout, chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = append(stderr, chunk);
+        });
+        child.once("error", (err) => {
+            error = err;
+        });
+        child.once("close", (status, signal) => {
+            if (timer)
+                clearTimeout(timer);
+            resolve({
+                status,
+                signal,
+                stdout,
+                stderr,
+                ...(error === undefined ? {} : { error }),
+                ...(timedOut ? { timedOut } : {}),
+            });
+        });
+        if (options.input === undefined)
+            child.stdin.end();
+        else
+            child.stdin.end(options.input);
+    });
+}
+export async function commandExists(command, env = process.env) {
+    if (process.platform === "win32") {
+        const names = [command, command.replace(/\.exe$/iu, ".cmd"), command.replace(/\.exe$/iu, ".bat")];
+        for (const name of names) {
+            const result = await runProcess("where", [name], { env, maxBufferBytes: 256 });
+            if (result.status === 0)
+                return true;
+        }
+        return false;
+    }
+    const result = await runProcess("sh", ["-lc", `command -v ${shellQuote(command)}`], { env, maxBufferBytes: 256 });
+    return result.status === 0;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/app/{conversation-entry-renderer.d.ts → rendering/conversation-entry-renderer.d.ts}

@@ -1,6 +1,6 @@
-import { type PixConfig } from "../config.js";
-import type { Theme } from "../theme.js";
-import type { Entry, RenderedLine } from "./types.js";
+import { type PixConfig } from "../../config.js";
+import type { Theme } from "../../theme.js";
+import type { Entry, RenderedLine } from "../types.js";
 export type InlineUserMessageMenuContext = {
     userContentWidth: number;
     userContentLeft: number;