pi-ui-extend 0.1.27 → 0.1.29

package/dist/app/screen/file-link-opener.js

@@ -11,6 +11,8 @@ export function setFileLinkOpenerTestDeps(overrides) {
     };
 }
 export function openFileLink(link) {
+    if (isWebUrl(link.url))
+        return openPathWithSystemViewer(link.url);
     const filePath = link.filePath ?? filePathFromUrl(link.url);
     if (!filePath)
         return false;
@@ -19,6 +21,9 @@ export function openFileLink(link) {
         return true;
     return openPathWithSystemViewer(filePath);
 }
+function isWebUrl(url) {
+    return url.startsWith("http://") || url.startsWith("https://");
+}
 function filePathFromUrl(url) {
     if (!url.startsWith("file://"))
         return undefined;

package/dist/app/screen/file-links.js

@@ -3,10 +3,11 @@ import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 const FILE_PATH_CANDIDATE = /(?<![\p{L}\p{N}_:])((?:file:\/\/\/|~[\\/]|\.{1,2}[\\/]|[A-Za-z]:[\\/]|[\\/]|[A-Za-z0-9_.@-]+[\\/])[^\s"'`<>]*)/gu;
+const WEB_URL_CANDIDATE = /https?:\/\/[^\s"'`<>]+/gu;
 const TRAILING_PUNCTUATION = new Set([".", ",", ";", ")", "]", "}"]);
 export function detectFileLinks(text, cwd) {
     const links = [];
-    if (!text.includes("/") && !text.includes("\\"))
+    if (!text.includes("/") && !text.includes("\\") && !text.includes("http://") && !text.includes("https://"))
         return links;
     for (const match of text.matchAll(FILE_PATH_CANDIDATE)) {
         const raw = match[1];
@@ -28,6 +29,17 @@ export function detectFileLinks(text, cwd) {
             column: location.column,
         });
     }
+    for (const match of text.matchAll(WEB_URL_CANDIDATE)) {
+        const raw = match[0];
+        const candidate = trimTrailingPunctuation(raw);
+        if (!candidate)
+            continue;
+        links.push({
+            start: match.index,
+            end: match.index + candidate.length,
+            url: candidate,
+        });
+    }
     return mergeOverlappingLinks(links);
 }
 export function hyperlink(text, url) {

package/dist/app/screen/mouse-controller.d.ts

@@ -139,6 +139,7 @@ export declare class AppMouseController {
     private inputClickFlashRegionForEvent;
     private imageTargetAt;
     private fileLinkAt;
+    private fileLinkTargetAt;
     private statusTargetAt;
     private handleImageClick;
     private handleFileLinkClick;

package/dist/app/screen/mouse-controller.js

@@ -60,6 +60,8 @@ export class AppMouseController {
         this.showClickFlashOnPress(event);
         if (event.button === 0 && !event.released && this.handleInputBorderStatusClick(event))
             return;
+        if (event.button === 0 && !event.released && this.fileLinkAt(event))
+            return;
         if (this.handleMouseSelection(event))
             return;
         if (this.withClickFlash(event, () => this.handleImageClick(event)))
@@ -234,9 +236,9 @@ export class AppMouseController {
         const imageTarget = this.imageTargetAt(event);
         if (imageTarget)
             return { y: event.y, startColumn: imageTarget.start + 1, endColumn: imageTarget.end + 1 };
-        const link = this.fileLinkAt(event);
-        if (link)
-            return { y: event.y, startColumn: link.start + 1, endColumn: link.end + 1 };
+        const linkTarget = this.fileLinkTargetAt(event);
+        if (linkTarget)
+            return { y: event.y, startColumn: linkTarget.startColumn, endColumn: linkTarget.endColumn };
         const tabTarget = this.tabLineTargetAt(event);
         if (tabTarget)
             return { y: tabTarget.row, startColumn: tabTarget.startColumn, endColumn: tabTarget.endColumn };
@@ -290,10 +292,19 @@ export class AppMouseController {
         return targets?.find((candidate) => event.x >= candidate.start + 1 && event.x <= candidate.end);
     }
     fileLinkAt(event) {
+        return this.fileLinkTargetAt(event)?.link;
+    }
+    fileLinkTargetAt(event) {
         const text = this.renderedRowTexts.get(event.y);
         if (!text)
             return undefined;
-        return detectFileLinks(text, this.host.cwd()).find((candidate) => event.x >= candidate.start + 1 && event.x <= candidate.end);
+        for (const link of detectFileLinks(text, this.host.cwd())) {
+            const startColumn = stringDisplayWidth(text.slice(0, link.start)) + 1;
+            const endColumn = startColumn + stringDisplayWidth(text.slice(link.start, link.end));
+            if (event.x >= startColumn && event.x < endColumn)
+                return { link, startColumn, endColumn };
+        }
+        return undefined;
     }
     statusTargetAt(event) {
         const target = [
@@ -323,7 +334,7 @@ export class AppMouseController {
         };
     }
     handleImageClick(event) {
-        if (event.button !== 0 || !event.released)
+        if (!isPrimaryButtonRelease(event))
             return false;
         const imageTarget = this.imageTargetAt(event);
         if (!imageTarget)
@@ -341,7 +352,7 @@ export class AppMouseController {
     }
     handleFileLinkClick(event) {
         const modifiedPress = isModifiedPrimaryButton(event.button) && !event.released;
-        const plainRelease = event.button === 0 && event.released;
+        const plainRelease = isPrimaryButtonRelease(event);
         if (!modifiedPress && !plainRelease)
             return false;
         const link = this.fileLinkAt(event);
@@ -1053,6 +1064,9 @@ function isModifiedPrimaryButton(button) {
     const modifierBits = button & (8 | 16);
     return primaryButton && modifierBits !== 0;
 }
+function isPrimaryButtonRelease(event) {
+    return event.released && (event.button === 0 || (event.button & 3) === 3);
+}
 function editorLayoutRows(terminalRows, tabPanelRows) {
     return Math.max(1, terminalRows - tabPanelRows);
 }

package/extensions/session-title/index.ts

@@ -70,6 +70,10 @@ export function firstUserMessageText(ctx: ExtensionContext): string | undefined
 	return undefined;
 }
 
+function hasExistingUserMessage(ctx: ExtensionContext): boolean {
+	return firstUserMessageText(ctx) !== undefined;
+}
+
 export function fallbackSessionTitleFromInput(input: string, maxTitleChars: number): string | undefined {
 	const normalized = input
 		.replace(/[\t\r\n]+/gu, " ")
@@ -371,24 +375,6 @@ export default function sessionTitle(pi: ExtensionAPI) {
 		})();
 	}
 
-	function primeTitleGenerationFromExistingSession(ctx: ExtensionContext, currentConfig: SessionTitleConfig): void {
-		if (currentSessionName(ctx)) return;
-
-		const input = firstUserMessageText(ctx);
-		if (!input) return;
-		if (!currentConfig.enabled) {
-			applyFallbackSessionTitle(ctx, currentConfig, input);
-			return;
-		}
-
-		pendingGeneration = {
-			sessionId: ctx.sessionManager.getSessionId(),
-			input: truncateInput(input, currentConfig.maxInputChars),
-			attempts: 0,
-		};
-		startTitleGeneration(ctx, currentConfig);
-	}
-
 	function isSameSessionPath(left: string | undefined, right: string | undefined): boolean {
 		if (!left || !right) return false;
 		if (left === right) return true;
@@ -447,7 +433,6 @@ export default function sessionTitle(pi: ExtensionAPI) {
 		await prepareForkTitleState(event, ctx);
 		refreshSessionUi(ctx, { force: true });
 		scheduleSessionUiRefresh(ctx);
-		if (!forkTitleState) primeTitleGenerationFromExistingSession(ctx, config);
 	});
 
 	pi.on("session_shutdown", async () => {
@@ -480,6 +465,10 @@ export default function sessionTitle(pi: ExtensionAPI) {
 		sessionId = currentSessionId;
 		const currentName = currentSessionName(ctx);
 		const activeForkTitleState = forkTitleState?.sessionId === currentSessionId ? forkTitleState : undefined;
+		if (!activeForkTitleState && hasExistingUserMessage(ctx)) {
+			forkTitleState = undefined;
+			return { action: "continue" as const };
+		}
 		if (currentName && (!activeForkTitleState || currentName !== activeForkTitleState.inheritedSessionName)) {
 			forkTitleState = undefined;
 			return { action: "continue" as const };

package/external/pi-tools-suite/src/lsp/constants.ts

@@ -1,6 +1,7 @@
 export const DEFAULT_STARTUP_TIMEOUT_MS = 45_000;
 export const DEFAULT_DIAGNOSTICS_WAIT_MS = 10_000;
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+export const DEFAULT_IDLE_SHUTDOWN_MS = 30_000;
 export const REQUEST_TIMEOUT_MS = 30_000;
 export const SHUTDOWN_WRITE_TIMEOUT_MS = 100;
 export const SHUTDOWN_TERM_TIMEOUT_MS = 2_000;

package/external/pi-tools-suite/src/lsp/manager.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_DIAGNOSTICS_WAIT_MS, DEFAULT_MAX_FILE_SIZE_BYTES, LSP_MANAGER_GLOBAL_KEY } from "./constants";
+import { DEFAULT_DIAGNOSTICS_WAIT_MS, DEFAULT_IDLE_SHUTDOWN_MS, DEFAULT_MAX_FILE_SIZE_BYTES, LSP_MANAGER_GLOBAL_KEY } from "./constants";
 import { DiagnosticsStore } from "./diagnostics-store";
 import { LspClient } from "./client";
 import { loadLspConfig } from "./_shared/config";
@@ -43,12 +43,51 @@ export class LspManager {
   private readonly diagnostics = new DiagnosticsStore();
   private readonly clients = new Map<string, LspClient>();
   private readonly backoff = new Map<string, { retryAt: number; attempts: number; reason: string }>();
+  private idleShutdownTimer: ReturnType<typeof setTimeout> | undefined;
+  private activeOperations = 0;
+  private handlingSignal = false;
   private readonly handleProcessExit = () => {
     this.shutdownAllSync();
   };
+  private readonly handleProcessSignal = (signal: NodeJS.Signals) => {
+    this.shutdownAllSync();
+
+    // Restore the platform default for the terminating signal. LSP servers are
+    // spawned detached so they can otherwise outlive Pi when the process is
+    // killed by a terminal/editor without a session_shutdown event.
+    if (this.handlingSignal) return;
+    this.handlingSignal = true;
+    process.kill(process.pid, signal);
+  };
 
   constructor() {
     process.once("exit", this.handleProcessExit);
+    process.once("SIGINT", this.handleProcessSignal);
+    process.once("SIGTERM", this.handleProcessSignal);
+    process.once("SIGHUP", this.handleProcessSignal);
+  }
+
+  private clearIdleShutdownTimer(): void {
+    if (!this.idleShutdownTimer) return;
+    clearTimeout(this.idleShutdownTimer);
+    this.idleShutdownTimer = undefined;
+  }
+
+  private beginOperation(): void {
+    this.activeOperations += 1;
+    this.clearIdleShutdownTimer();
+  }
+
+  private endOperation(): void {
+    this.activeOperations = Math.max(0, this.activeOperations - 1);
+    if (this.activeOperations > 0 || this.clients.size === 0) return;
+
+    this.clearIdleShutdownTimer();
+    this.idleShutdownTimer = setTimeout(() => {
+      if (this.activeOperations > 0 || this.clients.size === 0) return;
+      void this.shutdownAll();
+    }, DEFAULT_IDLE_SHUTDOWN_MS);
+    this.idleShutdownTimer.unref?.();
   }
 
   async matchingServers(ctx: ExtensionContext, file: string): Promise<{ matches: MatchedServer[]; warnings: string[]; workspace: string }> {
@@ -104,93 +143,98 @@ export class LspManager {
   }
 
   async updateDiagnosticsForFile(ctx: ExtensionContext, file: string): Promise<string> {
-    const { matches, warnings, workspace } = await this.matchingServers(ctx, file);
-    if (matches.length === 0) return formatWarnings("LSP diagnostics", warnings);
-
-    const lines: string[] = [];
-    for (const match of matches) {
-      try {
-        const maxFileSizeBytes = match.server.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
-        if (!(await fileSizeAllowed(file, maxFileSizeBytes))) {
-          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: skipped ${match.relFile}; file exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
-          continue;
-        }
+    this.beginOperation();
+    try {
+      const { matches, warnings, workspace } = await this.matchingServers(ctx, file);
+      if (matches.length === 0) return formatWarnings("LSP diagnostics", warnings);
 
-        // Clear stale diagnostics before refreshing this file. The synchronous
-        // wait below must observe a fresh publishDiagnostics notification, not an
-        // old error from a previous document version. Empty diagnostics published
-        // by the server are stored, but this local clear is not.
-        this.diagnostics.clear(match.server.id, match.root, filePathToUri(file));
-
-        const text = await readTextFile(file);
-        const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
-        const languageId = languageIdForFile(match.server, file);
-        const startedAt = Date.now();
-        const doc = await client.openOrChange(file, languageId, text, ctx.signal);
-        await client.didSave(file);
-        const diagnosticsWaitMs = match.server.diagnosticsWaitMs ?? DEFAULT_DIAGNOSTICS_WAIT_MS;
-
-        // typescript-language-server sometimes does not emit a fresh
-        // textDocument/publishDiagnostics notification after didChange/didSave,
-        // even though tsserver can answer diagnostics synchronously. Prefer the
-        // explicit tsserver request when the server exposes it, so post-edit
-        // diagnostics don't degrade into a misleading publishDiagnostics timeout.
-        let tsserverFallbackError: string | undefined;
+      const lines: string[] = [];
+      for (const match of matches) {
         try {
-          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
-          if (tsserverDiagnostics !== undefined) {
-            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+          const maxFileSizeBytes = match.server.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+          if (!(await fileSizeAllowed(file, maxFileSizeBytes))) {
+            lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: skipped ${match.relFile}; file exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
             continue;
           }
-        } catch (error) {
-          tsserverFallbackError = (error as Error).message;
-        }
 
-        let pullDiagnosticsError: string | undefined;
-        if (match.server.pullDiagnostics !== false) {
+          // Clear stale diagnostics before refreshing this file. The synchronous
+          // wait below must observe a fresh publishDiagnostics notification, not an
+          // old error from a previous document version. Empty diagnostics published
+          // by the server are stored, but this local clear is not.
+          this.diagnostics.clear(match.server.id, match.root, filePathToUri(file));
+
+          const text = await readTextFile(file);
+          const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
+          const languageId = languageIdForFile(match.server, file);
+          const startedAt = Date.now();
+          const doc = await client.openOrChange(file, languageId, text, ctx.signal);
+          await client.didSave(file);
+          const diagnosticsWaitMs = match.server.diagnosticsWaitMs ?? DEFAULT_DIAGNOSTICS_WAIT_MS;
+
+          // typescript-language-server sometimes does not emit a fresh
+          // textDocument/publishDiagnostics notification after didChange/didSave,
+          // even though tsserver can answer diagnostics synchronously. Prefer the
+          // explicit tsserver request when the server exposes it, so post-edit
+          // diagnostics don't degrade into a misleading publishDiagnostics timeout.
+          let tsserverFallbackError: string | undefined;
           try {
-            const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
-            if (pulledDiagnostics !== undefined) {
-              const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+            const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
+            if (tsserverDiagnostics !== undefined) {
+              const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
               this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
               lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
               continue;
             }
           } catch (error) {
-            pullDiagnosticsError = (error as Error).message;
+            tsserverFallbackError = (error as Error).message;
           }
-        }
 
-        if (match.server.waitForPublishDiagnostics === false || diagnosticsWaitMs <= 0) {
-          continue;
-        }
+          let pullDiagnosticsError: string | undefined;
+          if (match.server.pullDiagnostics !== false) {
+            try {
+              const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
+              if (pulledDiagnostics !== undefined) {
+                const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+                this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+                lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+                continue;
+              }
+            } catch (error) {
+              pullDiagnosticsError = (error as Error).message;
+            }
+          }
+
+          if (match.server.waitForPublishDiagnostics === false || diagnosticsWaitMs <= 0) {
+            continue;
+          }
 
-        const entry = await this.diagnostics.waitForFile(
-          match.server.id,
-          match.root,
-          file,
-          startedAt,
-          doc.version,
-          diagnosticsWaitMs,
-          ctx.signal,
-        );
-        if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
-          const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
-          const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
-          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
-          continue;
+          const entry = await this.diagnostics.waitForFile(
+            match.server.id,
+            match.root,
+            file,
+            startedAt,
+            doc.version,
+            diagnosticsWaitMs,
+            ctx.signal,
+          );
+          if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
+            const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
+            const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
+            lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
+            continue;
+          }
+          const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
+          if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+          lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+        } catch (error) {
+          lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: ${(error as Error).message}`);
         }
-        const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
-        if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
-        lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
-      } catch (error) {
-        lines.push(`${LSP_DIAGNOSTIC_ICON} ${match.server.id}: ${(error as Error).message}`);
       }
-    }
 
-    return [formatWarnings("LSP diagnostics", warnings), joinSections("LSP diagnostics", lines)].filter(Boolean).join("\n\n");
+      return [formatWarnings("LSP diagnostics", warnings), joinSections("LSP diagnostics", lines)].filter(Boolean).join("\n\n");
+    } finally {
+      this.endOperation();
+    }
   }
 
   async ensureDocumentForTool(ctx: ExtensionContext, inputPath: string): Promise<{ file: string; match: MatchedServer; client: LspClient; workspace: string } | undefined> {
@@ -215,15 +259,20 @@ export class LspManager {
   }
 
   async shutdownAll(): Promise<void> {
+    this.clearIdleShutdownTimer();
     const clients = [...this.clients.values()];
     this.clients.clear();
     await Promise.allSettled(clients.map((client) => client.shutdown()));
   }
 
   shutdownAllSync(): void {
+    this.clearIdleShutdownTimer();
     const clients = [...this.clients.values()];
     this.clients.clear();
     process.off("exit", this.handleProcessExit);
+    process.off("SIGINT", this.handleProcessSignal);
+    process.off("SIGTERM", this.handleProcessSignal);
+    process.off("SIGHUP", this.handleProcessSignal);
     for (const client of clients) client.shutdownSync();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "bin": {