merge: pull main, keep dark mode styling with non-virtualized list

Author: jonathanlab

apps/array/src/main/index.ts

@@ -1,10 +1,16 @@
+declare const __BUILD_COMMIT__: string | undefined;
+declare const __BUILD_DATE__: string | undefined;
+
 import dns from "node:dns";
 import { mkdirSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   app,
   BrowserWindow,
+  clipboard,
+  dialog,
   ipcMain,
   Menu,
   type MenuItemConstructorOptions,
@@ -116,7 +122,38 @@ function createWindow(): void {
     {
       label: "Array",
       submenu: [
-        { role: "about" },
+        {
+          label: "About Array",
+          click: () => {
+            const commit = __BUILD_COMMIT__ ?? "dev";
+            const buildDate = __BUILD_DATE__ ?? "dev";
+            const info = [
+              `Version: ${app.getVersion()}`,
+              `Commit: ${commit}`,
+              `Date: ${buildDate}`,
+              `Electron: ${process.versions.electron}`,
+              `Chromium: ${process.versions.chrome}`,
+              `Node.js: ${process.versions.node}`,
+              `V8: ${process.versions.v8}`,
+              `OS: ${process.platform} ${process.arch} ${os.release()}`,
+            ].join("\n");
+
+            dialog
+              .showMessageBox({
+                type: "info",
+                title: "About Array",
+                message: "Array",
+                detail: info,
+                buttons: ["Copy", "OK"],
+                defaultId: 1,
+              })
+              .then((result) => {
+                if (result.response === 0) {
+                  clipboard.writeText(info);
+                }
+              });
+          },
+        },
         { type: "separator" },
         {
           label: "Check for Updates...",

apps/array/src/main/services/session-manager.ts

@@ -23,6 +23,13 @@ import { logger } from "../lib/logger";
 
 const log = logger.scope("session-manager");
 
+function isAuthError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    error.message.startsWith("Authentication required")
+  );
+}
+
 type MessageCallback = (message: unknown) => void;
 
 class NdJsonTap {
@@ -135,6 +142,7 @@ export interface ManagedSession {
   createdAt: number;
   lastActivityAt: number;
   mockNodeDir: string;
+  config: SessionConfig;
 }
 
 function getClaudeCliPath(): string {
@@ -146,7 +154,7 @@ function getClaudeCliPath(): string {
 
 export class SessionManager {
   private sessions = new Map<string, ManagedSession>();
-  private sessionTokens = new Map<string, string>();
+  private currentToken: string | null = null;
   private getMainWindow: () => BrowserWindow | null;
   private onLog: OnLogCallback;
 
@@ -155,23 +163,20 @@ export class SessionManager {
     this.onLog = onLog;
   }
 
-  public updateSessionToken(taskRunId: string, newToken: string): void {
-    this.sessionTokens.set(taskRunId, newToken);
-    log.info("Session token updated", { taskRunId });
+  public updateToken(newToken: string): void {
+    this.currentToken = newToken;
+    log.info("Session token updated");
   }
 
-  private getSessionToken(taskRunId: string, fallback: string): string {
-    return this.sessionTokens.get(taskRunId) || fallback;
+  private getToken(fallback: string): string {
+    return this.currentToken || fallback;
   }
 
-  private buildMcpServers(
-    credentials: PostHogCredentials,
-    taskRunId: string,
-  ): AcpMcpServer[] {
+  private buildMcpServers(credentials: PostHogCredentials): AcpMcpServer[] {
     const servers: AcpMcpServer[] = [];
 
     const mcpUrl = this.getPostHogMcpUrl(credentials.apiHost);
-    const token = this.getSessionToken(taskRunId, credentials.apiKey);
+    const token = this.getToken(credentials.apiKey);
 
     servers.push({
       name: "posthog",
@@ -211,6 +216,7 @@ export class SessionManager {
   private async getOrCreateSession(
     config: SessionConfig,
     isReconnect: boolean,
+    isRetry = false,
   ): Promise<ManagedSession | null> {
     const {
       taskId,
@@ -222,9 +228,11 @@ export class SessionManager {
       model,
     } = config;
 
-    const existing = this.sessions.get(taskRunId);
-    if (existing) {
-      return existing;
+    if (!isRetry) {
+      const existing = this.sessions.get(taskRunId);
+      if (existing) {
+        return existing;
+      }
     }
 
     const channel = `agent-event:${taskRunId}`;
@@ -234,7 +242,7 @@ export class SessionManager {
     const agent = new Agent({
       workingDirectory: repoPath,
       posthogApiUrl: credentials.apiHost,
-      posthogApiKey: credentials.apiKey,
+      getPosthogApiKey: () => this.getToken(credentials.apiKey),
       posthogProjectId: credentials.projectId,
       debug: !app.isPackaged,
       onLog: this.onLog,
@@ -256,11 +264,9 @@ export class SessionManager {
         clientCapabilities: {},
       });
 
-      const mcpServers = this.buildMcpServers(credentials, taskRunId);
+      const mcpServers = this.buildMcpServers(credentials);
 
       if (isReconnect) {
-        // Use our custom extension method to resume without replaying history.
-        // Client fetches history from S3 directly.
         await connection.extMethod("_posthog/session/resume", {
           sessionId: taskRunId,
           cwd: repoPath,
@@ -290,38 +296,82 @@ export class SessionManager {
         createdAt: Date.now(),
         lastActivityAt: Date.now(),
         mockNodeDir,
+        config,
       };
 
       this.sessions.set(taskRunId, session);
+      if (isRetry) {
+        log.info("Session created after auth retry", { taskRunId });
+      }
       return session;
     } catch (err) {
       this.cleanupMockNodeEnvironment(mockNodeDir);
+      if (!isRetry && isAuthError(err)) {
+        log.warn(
+          `Auth error during ${isReconnect ? "reconnect" : "create"}, retrying`,
+          { taskRunId },
+        );
+        return this.getOrCreateSession(config, isReconnect, true);
+      }
       log.error(
-        `Failed to ${isReconnect ? "reconnect" : "create"} session`,
+        `Failed to ${isReconnect ? "reconnect" : "create"} session${isRetry ? " after retry" : ""}`,
         err,
       );
       if (isReconnect) return null;
       throw err;
     }
   }
 
+  private async recreateSession(taskRunId: string): Promise<ManagedSession> {
+    const existing = this.sessions.get(taskRunId);
+    if (!existing) {
+      throw new Error(`Session not found for recreation: ${taskRunId}`);
+    }
+
+    log.info("Recreating session due to auth error", { taskRunId });
+
+    // Store config and cleanup old session
+    const config = existing.config;
+    this.cleanupSession(taskRunId);
+
+    // Reconnect to preserve Claude context via sdkSessionId
+    const newSession = await this.getOrCreateSession(config, true);
+    if (!newSession) {
+      throw new Error(`Failed to recreate session: ${taskRunId}`);
+    }
+
+    return newSession;
+  }
+
   async prompt(
     taskRunId: string,
     prompt: ContentBlock[],
   ): Promise<{ stopReason: string }> {
-    const session = this.sessions.get(taskRunId);
+    let session = this.sessions.get(taskRunId);
     if (!session) {
       throw new Error(`Session not found: ${taskRunId}`);
     }
 
     session.lastActivityAt = Date.now();
 
-    const result = await session.connection.prompt({
-      sessionId: taskRunId, // Use taskRunId as ACP sessionId
-      prompt,
-    });
-
-    return { stopReason: result.stopReason };
+    try {
+      const result = await session.connection.prompt({
+        sessionId: taskRunId,
+        prompt,
+      });
+      return { stopReason: result.stopReason };
+    } catch (err) {
+      if (isAuthError(err)) {
+        log.warn("Auth error during prompt, recreating session", { taskRunId });
+        session = await this.recreateSession(taskRunId);
+        const result = await session.connection.prompt({
+          sessionId: taskRunId,
+          prompt,
+        });
+        return { stopReason: result.stopReason };
+      }
+      throw err;
+    }
   }
 
   async cancelSession(taskRunId: string): Promise<boolean> {
@@ -398,11 +448,12 @@ export class SessionManager {
     credentials: PostHogCredentials,
     mockNodeDir: string,
   ): void {
+    const token = this.getToken(credentials.apiKey);
     const newPath = `${mockNodeDir}:${process.env.PATH || ""}`;
     process.env.PATH = newPath;
-    process.env.POSTHOG_AUTH_HEADER = `Bearer ${credentials.apiKey}`;
-    process.env.ANTHROPIC_API_KEY = credentials.apiKey;
-    process.env.ANTHROPIC_AUTH_TOKEN = credentials.apiKey;
+    process.env.POSTHOG_AUTH_HEADER = `Bearer ${token}`;
+    process.env.ANTHROPIC_API_KEY = token;
+    process.env.ANTHROPIC_AUTH_TOKEN = token;
 
     const llmGatewayUrl =
       process.env.LLM_GATEWAY_URL ||
@@ -508,6 +559,24 @@ export class SessionManager {
         // No-op: session/update notifications are captured by the stream tap
         // and forwarded as acp_message events to avoid duplication
       },
+
+      extNotification: async (
+        method: string,
+        params: Record<string, unknown>,
+      ): Promise<void> => {
+        if (method === "_posthog/sdk_session") {
+          const { sessionId, sdkSessionId } = params as {
+            sessionId: string;
+            sdkSessionId: string;
+          };
+          // Store sdkSessionId in session config for recreation/reconnection
+          const session = this.sessions.get(sessionId);
+          if (session) {
+            session.config.sdkSessionId = sdkSessionId;
+            log.info("SDK session ID captured", { sessionId, sdkSessionId });
+          }
+        }
+      },
     };
 
     // Create client-side connection with tapped streams (bidirectional)
@@ -665,10 +734,10 @@ export function registerAgentIpc(
     "agent-token-refresh",
     async (
       _event: IpcMainInvokeEvent,
-      taskRunId: string,
+      _taskRunId: string,
       newToken: string,
     ): Promise<void> => {
-      sessionManager.updateSessionToken(taskRunId, newToken);
+      sessionManager.updateToken(newToken);
     },
   );
 

apps/array/src/renderer/features/auth/stores/authStore.ts

@@ -202,6 +202,13 @@ export const useAuthStore = create<AuthState>()(
             ...(projectId && { projectId }),
           });
 
+          // Notify main process of token refresh for active agent sessions
+          window.electronAPI
+            .agentTokenRefresh("", tokenResponse.access_token)
+            .catch((err) => {
+              log.warn("Failed to update agent token:", err);
+            });
+
           get().scheduleTokenRefresh();
         },
 

apps/array/src/renderer/features/code-editor/components/CodeEditorPanel.tsx

@@ -64,6 +64,7 @@ export function CodeEditorPanel({
       <CodeMirrorEditor
         content={fileContent}
         filePath={absolutePath}
+        relativePath={filePath}
         readOnly
       />
     </Box>

apps/array/src/renderer/features/code-editor/components/CodeMirrorDiffEditor.tsx

@@ -1,4 +1,4 @@
-import { Box, Flex, SegmentedControl } from "@radix-ui/themes";
+import { Box, Flex, SegmentedControl, Text } from "@radix-ui/themes";
 import { useMemo } from "react";
 import { useCodeMirror } from "../hooks/useCodeMirror";
 import { useEditorExtensions } from "../hooks/useEditorExtensions";
@@ -8,13 +8,15 @@ interface CodeMirrorDiffEditorProps {
   originalContent: string;
   modifiedContent: string;
   filePath?: string;
+  relativePath?: string;
   onContentChange?: (content: string) => void;
 }
 
 export function CodeMirrorDiffEditor({
   originalContent,
   modifiedContent,
   filePath,
+  relativePath,
   onContentChange,
 }: CodeMirrorDiffEditorProps) {
   const { viewMode, setViewMode } = useDiffViewerStore();
@@ -41,11 +43,22 @@ export function CodeMirrorDiffEditor({
 
   return (
     <Flex direction="column" height="100%">
-      <Box
+      <Flex
         px="3"
         py="2"
+        align="center"
+        justify="between"
         style={{ borderBottom: "1px solid var(--gray-6)", flexShrink: 0 }}
       >
+        {relativePath && (
+          <Text
+            size="1"
+            color="gray"
+            style={{ fontFamily: "var(--code-font-family)" }}
+          >
+            {relativePath}
+          </Text>
+        )}
         <SegmentedControl.Root
           size="1"
           value={viewMode}
@@ -54,7 +67,7 @@ export function CodeMirrorDiffEditor({
           <SegmentedControl.Item value="split">Split</SegmentedControl.Item>
           <SegmentedControl.Item value="unified">Unified</SegmentedControl.Item>
         </SegmentedControl.Root>
-      </Box>
+      </Flex>
       <Box style={{ flex: 1, overflow: "auto" }}>
         <div ref={containerRef} style={{ height: "100%", width: "100%" }} />
       </Box>