pi-ui-extend 1.0.2 → 1.0.4

package/README.md

@@ -439,7 +439,7 @@ cd /path/to/project
 pix
 ```
 
-`/idx-update` updates the globally installed `indexer-cli`; it does not refresh a project's index.
+When `indexer-cli` is installed and available on `PATH`, Pix checks it at startup and runs its official updater when needed. Pix silently skips this check when `idx` is absent. `/idx-update` remains available for a manual retry; neither flow refreshes a project's index.
 
 ### An extension behaves differently
 

package/dist/app/app.d.ts

@@ -72,7 +72,7 @@ export declare class PiUiExtendApp {
     private applyPixConfig;
     private updateOutputFilters;
     start(): Promise<void>;
-    private checkPixUpdateOnStartup;
+    private checkUpdatesOnStartup;
     private bindCurrentSession;
     private awaitCurrentSessionExtensions;
     private activateRuntime;

package/dist/app/app.js

@@ -43,6 +43,7 @@ import { AppTerminalController } from "./terminal/terminal-controller.js";
 import { TerminalBellSoundController } from "./terminal/terminal-bell-sound-controller.js";
 import { AppToastController } from "./rendering/toast-controller.js";
 import { checkPiUpdate, checkPixUpdate, formatPixStartupUpdateDialog, formatPiStartupUpdateToast } from "./cli/update.js";
+import { checkAndUpdateIdxOnStartup, formatIdxStartupUpdateNotice } from "./cli/startup-checks.js";
 import { AppVoiceController } from "./input/voice-controller.js";
 import { createIsolatedExtensionEventBus } from "./extensions/extension-event-bus.js";
 import { setAppIconTheme } from "./icons.js";
@@ -864,9 +865,21 @@ export class PiUiExtendApp {
         await this.sessionLifecycle.start();
         this.modelUsageController.startPolling();
         this.nerdFontController.ensureInstalledOnStartup();
-        this.checkPixUpdateOnStartup();
+        this.checkUpdatesOnStartup();
     }
-    checkPixUpdateOnStartup() {
+    checkUpdatesOnStartup() {
+        void checkAndUpdateIdxOnStartup()
+            .then((result) => {
+            if (!this.running)
+                return;
+            const notice = formatIdxStartupUpdateNotice(result);
+            if (!notice)
+                return;
+            this.showToast(notice, result.status === "updated" ? "success" : "warning");
+        })
+            .catch(() => {
+            // Startup update checks should never interrupt the TUI.
+        });
         void checkPiUpdate()
             .then((result) => {
             if (result.status !== "newer")

package/dist/app/cli/startup-checks.d.ts

@@ -3,7 +3,29 @@ export type StartupAvailabilityIssue = {
     kind: "warning" | "error";
     message: string;
 };
+export type IdxStartupUpdateStatus = "current" | "updated" | "checked" | "skipped" | "unavailable" | "failed";
+export type IdxStartupUpdateResult = {
+    status: IdxStartupUpdateStatus;
+    previousVersion?: string;
+    currentVersion?: string;
+    reason?: string;
+};
+type IdxUpdateCommandResult = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timedOut?: boolean;
+};
+export type IdxStartupUpdateOptions = {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    runUpdate?: (timeoutMs: number, env: NodeJS.ProcessEnv) => Promise<IdxUpdateCommandResult>;
+};
 export declare function collectStartupAvailabilityIssues(runtime: AgentSessionRuntime): Promise<StartupAvailabilityIssue[]>;
 export declare function checkSelectedModelAuthAvailability(runtime: AgentSessionRuntime): StartupAvailabilityIssue[];
 export declare function checkPiCliAvailability(pathValue?: string): Promise<StartupAvailabilityIssue[]>;
+export declare function checkAndUpdateIdxOnStartup(options?: IdxStartupUpdateOptions): Promise<IdxStartupUpdateResult>;
+export declare function formatIdxStartupUpdateNotice(result: IdxStartupUpdateResult): string | undefined;
 export declare function checkPiToolsSuiteExtensionAvailability(extensionsResult: LoadExtensionsResult): StartupAvailabilityIssue[];
+export {};

package/dist/app/cli/startup-checks.js

@@ -1,8 +1,12 @@
+import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { constants as fsConstants } from "node:fs";
 const PI_CLI_COMMAND = "pi";
 const PI_TOOLS_SUITE_EXTENSION_ID = "pi-tools-suite";
+const IDX_CLI_COMMAND = "idx";
+const IDX_UPDATE_TIMEOUT_MS = 600_000;
+const MAX_IDX_UPDATE_OUTPUT_BYTES = 32_000;
 export async function collectStartupAvailabilityIssues(runtime) {
     return [
         ...(await checkPiCliAvailability()),
@@ -33,6 +37,60 @@ export async function checkPiCliAvailability(pathValue = process.env.PATH ?? "")
             message: "pi CLI is not available on PATH. Run `pix install` or add pi to PATH before starting pix.",
         }];
 }
+export async function checkAndUpdateIdxOnStartup(options = {}) {
+    const env = options.env ?? process.env;
+    const disabledReason = startupVersionCheckDisabledReason(env);
+    if (disabledReason)
+        return { status: "skipped", reason: disabledReason };
+    if (!options.runUpdate && !(await executableExistsOnPath(IDX_CLI_COMMAND, env.PATH ?? ""))) {
+        return { status: "unavailable" };
+    }
+    let commandResult;
+    try {
+        commandResult = await (options.runUpdate ?? runIdxUpdate)(options.timeoutMs ?? IDX_UPDATE_TIMEOUT_MS, env);
+    }
+    catch (error) {
+        if (isCommandNotFoundError(error)) {
+            return { status: "unavailable" };
+        }
+        return { status: "failed", reason: errorMessage(error) };
+    }
+    const output = [commandResult.stdout, commandResult.stderr].filter(Boolean).join("\n").trim();
+    if (commandResult.timedOut) {
+        return { status: "failed", reason: compactCommandFailure("idx update timed out", output) };
+    }
+    if (commandResult.code !== 0) {
+        const termination = commandResult.signal
+            ? `idx update terminated by signal ${commandResult.signal}`
+            : `idx update exited with code ${commandResult.code ?? "unknown"}`;
+        return { status: "failed", reason: compactCommandFailure(termination, output) };
+    }
+    const updatedVersions = parseUpdatedIdxVersions(output);
+    if (updatedVersions)
+        return { status: "updated", ...updatedVersions };
+    const currentVersion = parseCurrentIdxVersion(output);
+    if (currentVersion)
+        return { status: "current", currentVersion };
+    return { status: "checked" };
+}
+export function formatIdxStartupUpdateNotice(result) {
+    switch (result.status) {
+        case "updated": {
+            if (!result.currentVersion)
+                return "idx was updated to the latest version.";
+            const previousVersion = result.previousVersion ? ` from ${result.previousVersion}` : "";
+            return `idx updated${previousVersion} to ${result.currentVersion}.`;
+        }
+        case "unavailable":
+            return undefined;
+        case "failed":
+            return `idx startup update failed: ${result.reason ?? "unknown error"}`;
+        case "current":
+        case "checked":
+        case "skipped":
+            return undefined;
+    }
+}
 export function checkPiToolsSuiteExtensionAvailability(extensionsResult) {
     if (extensionsResult.extensions.some(isPiToolsSuiteExtension))
         return [];
@@ -64,6 +122,95 @@ async function executableExistsOnPath(command, pathValue) {
     }
     return false;
 }
+async function runIdxUpdate(timeoutMs, env) {
+    return await new Promise((resolve, reject) => {
+        const invocation = idxUpdateInvocation(env);
+        const child = spawn(invocation.command, invocation.args, {
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        timer.unref();
+        child.stdout?.on("data", (chunk) => {
+            stdout = appendBoundedOutput(stdout, chunk.toString());
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr = appendBoundedOutput(stderr, chunk.toString());
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, signal, stdout, stderr, ...(timedOut ? { timedOut: true } : {}) });
+        });
+    });
+}
+function idxUpdateInvocation(env) {
+    if (process.platform !== "win32")
+        return { command: IDX_CLI_COMMAND, args: ["update"] };
+    const commandProcessor = env.ComSpec ?? env.COMSPEC ?? process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe";
+    return { command: commandProcessor, args: ["/d", "/s", "/c", `${IDX_CLI_COMMAND} update`] };
+}
+function appendBoundedOutput(existing, addition) {
+    const combined = `${existing}${addition}`;
+    if (Buffer.byteLength(combined, "utf8") <= MAX_IDX_UPDATE_OUTPUT_BYTES)
+        return combined;
+    return Buffer.from(combined, "utf8").subarray(-MAX_IDX_UPDATE_OUTPUT_BYTES).toString("utf8").replace(/^\uFFFD/u, "");
+}
+function parseUpdatedIdxVersions(output) {
+    const match = output.match(/(?:Updating|Updated) indexer-cli\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\s*(?:→|->)\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/iu);
+    const previousVersion = match?.[1];
+    const currentVersion = match?.[2];
+    if (!previousVersion || !currentVersion)
+        return undefined;
+    return { previousVersion, currentVersion };
+}
+function parseCurrentIdxVersion(output) {
+    return output.match(/already up to date\s*\(v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\)/iu)?.[1];
+}
+function startupVersionCheckDisabledReason(env) {
+    if (truthyEnv(env.PI_OFFLINE))
+        return "PI_OFFLINE is set";
+    if (truthyEnv(env.PI_SKIP_VERSION_CHECK))
+        return "PI_SKIP_VERSION_CHECK is set";
+    if (truthyEnv(env.PIX_SKIP_VERSION_CHECK))
+        return "PIX_SKIP_VERSION_CHECK is set";
+    return undefined;
+}
+function truthyEnv(value) {
+    if (!value)
+        return false;
+    return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function isCommandNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function compactCommandFailure(prefix, output) {
+    if (!output)
+        return prefix;
+    const singleLine = output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).slice(-4).join(" | ");
+    const summary = singleLine.length > 900 ? `${singleLine.slice(0, 897)}...` : singleLine;
+    return `${prefix}: ${summary}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function isPiToolsSuiteExtension(extension) {
     return [
         extension.path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {