TypeAgent chat panel for VS Code

dotnet/autoShell/Services/WindowsWindowService.cs

@@ -21,6 +21,7 @@ internal class WindowsWindowService : IWindowService
     private const uint WM_SYSCOMMAND = 0x112;
     private const uint SC_MAXIMIZE = 0xF030;
     private const uint SC_MINIMIZE = 0xF020;
+    private const uint SW_RESTORE = 9;
 
     private struct RECT
     {
@@ -30,40 +31,55 @@ private struct RECT
         public int Bottom;
     }
 
+    private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    [DllImport(NativeDlls.User32, SetLastError = true)]
+    private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);
+
     [DllImport(NativeDlls.User32)]
-    private static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
+    private static extern bool BringWindowToTop(IntPtr hWnd);
 
     [DllImport(NativeDlls.User32)]
-    private static extern IntPtr GetDesktopWindow();
+    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
 
     [DllImport(NativeDlls.User32)]
-    private static extern bool SetForegroundWindow(IntPtr hWnd);
+    private static extern IntPtr FindWindowEx(IntPtr hWndParent, IntPtr hWndChildAfter, string lpClassName, string lpWindowName);
 
-    [DllImport(NativeDlls.User32, EntryPoint = "SendMessage", SetLastError = true)]
-    private static extern IntPtr SendMessage(IntPtr hWnd, uint msg, uint wParam, IntPtr lParam);
+    [DllImport("kernel32.dll")]
+    private static extern uint GetCurrentThreadId();
 
     [DllImport(NativeDlls.User32)]
-    private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);
+    private static extern IntPtr GetDesktopWindow();
 
     [DllImport(NativeDlls.User32)]
-    private static extern bool ShowWindow(IntPtr hWnd, uint nCmdShow);
+    private static extern IntPtr GetForegroundWindow();
 
     [DllImport(NativeDlls.User32)]
-    private static extern IntPtr FindWindowEx(IntPtr hWndParent, IntPtr hWndChildAfter, string lpClassName, string lpWindowName);
+    private static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
 
-    private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+    [DllImport(NativeDlls.User32)]
+    private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
 
     [DllImport(NativeDlls.User32)]
-    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
 
     [DllImport(NativeDlls.User32)]
-    private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
+    private static extern bool IsIconic(IntPtr hWnd);
 
     [DllImport(NativeDlls.User32)]
     private static extern bool IsWindowVisible(IntPtr hWnd);
 
+    [DllImport(NativeDlls.User32, EntryPoint = "SendMessage", SetLastError = true)]
+    private static extern IntPtr SendMessage(IntPtr hWnd, uint msg, uint wParam, IntPtr lParam);
+
     [DllImport(NativeDlls.User32)]
-    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+    private static extern bool SetForegroundWindow(IntPtr hWnd);
+
+    [DllImport(NativeDlls.User32)]
+    private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);
+
+    [DllImport(NativeDlls.User32)]
+    private static extern bool ShowWindow(IntPtr hWnd, uint nCmdShow);
 
     #endregion
 
@@ -118,6 +134,57 @@ public void MinimizeWindow(string processName)
         }
     }
 
+    /// <summary>
+    /// Bring a window to the foreground reliably. Windows blocks
+    /// SetForegroundWindow from background processes by design (taskbar
+    /// flash only). The standard workaround is to attach the calling
+    /// thread's input queue to the current foreground window's thread,
+    /// during which SetForegroundWindow is permitted.
+    /// </summary>
+    private static void ForceForeground(IntPtr hWnd)
+    {
+        if (hWnd == IntPtr.Zero) return;
+
+        if (IsIconic(hWnd))
+        {
+            ShowWindow(hWnd, SW_RESTORE);
+        }
+
+        IntPtr foregroundHwnd = GetForegroundWindow();
+        uint foregroundThreadId = foregroundHwnd != IntPtr.Zero
+            ? GetWindowThreadProcessId(foregroundHwnd, out _)
+            : 0;
+        uint targetThreadId = GetWindowThreadProcessId(hWnd, out _);
+        uint currentThreadId = GetCurrentThreadId();
+
+        bool attachedFg = false;
+        bool attachedTarget = false;
+        try
+        {
+            if (foregroundThreadId != 0 && foregroundThreadId != currentThreadId)
+            {
+                attachedFg = AttachThreadInput(currentThreadId, foregroundThreadId, true);
+            }
+            if (targetThreadId != 0 && targetThreadId != currentThreadId && targetThreadId != foregroundThreadId)
+            {
+                attachedTarget = AttachThreadInput(currentThreadId, targetThreadId, true);
+            }
+            BringWindowToTop(hWnd);
+            SetForegroundWindow(hWnd);
+        }
+        finally
+        {
+            if (attachedFg)
+            {
+                AttachThreadInput(currentThreadId, foregroundThreadId, false);
+            }
+            if (attachedTarget)
+            {
+                AttachThreadInput(currentThreadId, targetThreadId, false);
+            }
+        }
+    }
+
     /// <inheritdoc/>
     public void RaiseWindow(string processName, string executablePath)
     {
@@ -126,7 +193,7 @@ public void RaiseWindow(string processName, string executablePath)
         {
             if (p.MainWindowHandle != IntPtr.Zero)
             {
-                SetForegroundWindow(p.MainWindowHandle);
+                ForceForeground(p.MainWindowHandle);
                 Interaction.AppActivate(p.Id);
                 return;
             }
@@ -143,7 +210,7 @@ public void RaiseWindow(string processName, string executablePath)
             (nint hWnd1, int pid) = FindWindowByTitle(processName);
             if (hWnd1 != nint.Zero)
             {
-                SetForegroundWindow(hWnd1);
+                ForceForeground(hWnd1);
                 Interaction.AppActivate(pid);
             }
         }
@@ -228,7 +295,6 @@ public void TileWindows(string processName1, string processName2)
             uint showWindow = 0x40;
 
             // Restore windows first (SetWindowPos won't work on maximized windows)
-            uint SW_RESTORE = 9;
             ShowWindow(hWnd1, SW_RESTORE);
             ShowWindow(hWnd2, SW_RESTORE);
 

ts/packages/agentRpc/src/rpc.ts

@@ -62,7 +62,21 @@ export function createRpc<
             if (f === undefined) {
                 debugError("No call handler", message);
             } else {
-                f(...message.args);
+                // Call handlers are fire-and-forget (no callId), so any
+                // synchronous throw cannot be reported back to the caller.
+                // Swallow it here to keep the RPC bus alive — otherwise a
+                // single bad notify (e.g. cancelCommand after the remote
+                // dispatcher channel disconnected) would surface as an
+                // uncaught exception in the host process.
+                try {
+                    f(...message.args);
+                } catch (e: any) {
+                    debugError(
+                        "Call handler threw",
+                        message.name,
+                        e?.message ?? e,
+                    );
+                }
             }
             return;
         }

ts/packages/agentServer/server/src/conversationManager.ts

@@ -88,24 +88,57 @@ export async function createConversationManager(
     idleTimeoutMs: number = DEFAULT_IDLE_TIMEOUT_MS,
 ): Promise<ConversationManager> {
     const conversationsDir = path.join(baseDir, CONVERSATIONS_DIR);
-    await fs.promises.mkdir(conversationsDir, { recursive: true });
 
-    // Migrate old on-disk layout: "server-sessions/" → "conversations/"
+    // TODO: deprecate and remove this on-disk migration once enough time has
+    // passed that no production install still has a "server-sessions/"
+    // directory hanging around.
+    // Migrate old on-disk layout: "server-sessions/" → "conversations/".
+    // IMPORTANT: do this BEFORE creating the destination — otherwise
+    // `fs.rename` fails with EPERM/EEXIST on Windows when the target
+    // already exists, silently stranding all historical conversations
+    // in the old directory.
     const oldConversationsDir = path.join(baseDir, "server-sessions");
-    try {
-        await fs.promises.rename(oldConversationsDir, conversationsDir);
-        debugConversation(
-            `Migrated on-disk directory "server-sessions" → "conversations"`,
-        );
-    } catch (e: any) {
-        if (
-            e?.code !== "ENOENT" &&
-            e?.code !== "EEXIST" &&
-            e?.code !== "EPERM"
-        ) {
+    if (
+        !fs.existsSync(conversationsDir) &&
+        fs.existsSync(oldConversationsDir)
+    ) {
+        try {
+            await fs.promises.rename(oldConversationsDir, conversationsDir);
+            debugConversation(
+                `Migrated on-disk directory "server-sessions" → "conversations"`,
+            );
+        } catch (e: any) {
             debugConversationErr("Failed to migrate server-sessions dir:", e);
         }
+    } else if (fs.existsSync(oldConversationsDir)) {
+        // Both directories exist — earlier builds raced and pre-created
+        // the destination. Move stragglers across so users don't lose history.
+        try {
+            for (const entry of await fs.promises.readdir(oldConversationsDir, {
+                withFileTypes: true,
+            })) {
+                const src = path.join(oldConversationsDir, entry.name);
+                const dst = path.join(conversationsDir, entry.name);
+                if (fs.existsSync(dst)) continue;
+                try {
+                    await fs.promises.rename(src, dst);
+                } catch (e: any) {
+                    debugConversationErr(`Failed to migrate ${entry.name}:`, e);
+                }
+            }
+            // Best-effort cleanup; will fail silently if non-empty.
+            await fs.promises.rmdir(oldConversationsDir).catch(() => undefined);
+            debugConversation(
+                `Merged stragglers from "server-sessions" → "conversations"`,
+            );
+        } catch (e: any) {
+            debugConversationErr(
+                "Failed to merge server-sessions stragglers:",
+                e,
+            );
+        }
     }
+    await fs.promises.mkdir(conversationsDir, { recursive: true });
     // Migrate old metadata filename: "sessions.json" → "conversations.json"
     const oldMetadataPath = path.join(conversationsDir, "sessions.json");
     const newMetadataPath = path.join(conversationsDir, METADATA_FILE);
@@ -127,6 +160,11 @@ export async function createConversationManager(
 
     const conversations = new Map<string, ConversationRecord>();
 
+    // Single-flight lock for "auto-create the default conversation". Two
+    // concurrent first-connects could both observe "no conversations exist"
+    // and race; this serializes them so only one create happens.
+    let defaultCreateP: Promise<string> | undefined;
+
     // Load persisted metadata
     await loadMetadata();
 
@@ -315,6 +353,23 @@ export async function createConversationManager(
         }
     }
 
+    /**
+     * Throw if `name` collides (case-insensitive) with another existing
+     * conversation. `selfId` is excluded from the check so renaming a
+     * conversation to its current name is a no-op rather than an error.
+     */
+    function ensureNameAvailable(name: string, selfId?: string): void {
+        const norm = name.trim().toLowerCase();
+        for (const [id, record] of conversations) {
+            if (id === selfId) continue;
+            if (record.name.trim().toLowerCase() === norm) {
+                throw new Error(
+                    `A conversation named "${record.name}" already exists. Pick a different name.`,
+                );
+            }
+        }
+    }
+
     // Sweep orphaned ephemeral conversations left behind by unclean CLI exits
     {
         const toSweep: string[] = [];
@@ -350,6 +405,7 @@ export async function createConversationManager(
     const manager: ConversationManager = {
         async createConversation(name: string): Promise<ConversationInfo> {
             validateConversationName(name);
+            ensureNameAvailable(name);
             const conversationId = randomUUID();
             const createdAt = new Date().toISOString();
             const record: ConversationRecord = {
@@ -391,9 +447,23 @@ export async function createConversationManager(
             if (resolved !== undefined) {
                 return resolved;
             }
-            // No conversations exist — auto-create a default
-            const info = await manager.createConversation("default");
-            return info.conversationId;
+            // No conversations exist — auto-create a default. Serialize so two
+            // concurrent first-connects don't both try to create "default" and
+            // race the duplicate-name check.
+            if (defaultCreateP === undefined) {
+                defaultCreateP = (async () => {
+                    // Re-check inside the critical section in case another caller
+                    // raced us between the early check above and acquiring the lock.
+                    const existing =
+                        getDefaultConversationId() ?? getAnyConversationId();
+                    if (existing !== undefined) return existing;
+                    const info = await manager.createConversation("default");
+                    return info.conversationId;
+                })().finally(() => {
+                    defaultCreateP = undefined;
+                });
+            }
+            return defaultCreateP;
         },
 
         async prewarmMostRecentConversation(): Promise<void> {
@@ -440,7 +510,7 @@ export async function createConversationManager(
             // Notify existing clients that a new client has joined
             if (sharedDispatcher.clientCount > 1 && dispatcher.connectionId) {
                 sharedDispatcher.broadcastSystemMessage(
-                    `[A new client has joined this conversation. You are connected to '${record.name}'.]`,
+                    `[A new client has joined this conversation.]`,
                     dispatcher.connectionId,
                 );
             }
@@ -474,7 +544,7 @@ export async function createConversationManager(
             // Notify remaining clients before this client leaves
             if (record.sharedDispatcher.clientCount > 1) {
                 record.sharedDispatcher.broadcastSystemMessage(
-                    `[A client has left this conversation. You remain connected to '${record.name}'.]`,
+                    `[A client has left this conversation.]`,
                     connectionId,
                 );
             }
@@ -518,6 +588,7 @@ export async function createConversationManager(
             if (record === undefined) {
                 throw new Error(`Conversation not found: ${conversationId}`);
             }
+            ensureNameAvailable(newName, conversationId);
             record.name = newName;
             await saveMetadata();
             debugConversation(

ts/packages/agentServer/server/src/server.ts

@@ -434,4 +434,13 @@ process.on("uncaughtException", (err) => {
     // Log but do not exit for non-fatal errors.
 });
 
-await main();
+await main().catch((err: any) => {
+    if (err?.code === "ERR_INSTANCE_LOCKED") {
+        // Friendly, single-line message — no stack trace for this expected
+        // case (another shell/server already owns the profile directory).
+        console.error(`\n[agent-server] ${err.message}\n`);
+        process.exit(1);
+    }
+    console.error("[agent-server] Fatal startup error:", err);
+    process.exit(1);
+});