ai-agent-session-center 2.8.2 → 2.9.4

package/server/apiRouter.ts

@@ -10,7 +10,7 @@ function str(val: unknown): string {
   if (Array.isArray(val)) return String(val[0] ?? '');
   return val != null ? String(val) : '';
 }
-import { findClaudeProcess, killSession, archiveSession, setSessionTitle, setSessionLabel, setSessionPinned, setSessionAccentColor, setSummary, getSession, getAllSessions, detectSessionSource, createTerminalSession, findActiveSessionByConfig, deleteSessionFromMemory, resumeSession, reconnectSessionTerminal, reconnectOpsTerminal } from './sessionStore.js';
+import { findClaudeProcess, killSession, archiveSession, setSessionTitle, setSessionLabel, setSessionPinned, setSessionAccentColor, setSessionCharacterModel, setSummary, getSession, getAllSessions, detectSessionSource, createTerminalSession, findActiveSessionByConfig, deleteSessionFromMemory, resumeSession, reconnectSessionTerminal, reconnectOpsTerminal } from './sessionStore.js';
 import { config as serverConfig } from './serverConfig.js';
 import { createTerminal, closeTerminal, getTerminals, listSshKeys, listTmuxSessions, writeToTerminal, writeWhenReady, attachToTmuxPane, consumePendingLink } from './sshManager.js';
 import { getTeam, readTeamConfig } from './teamManager.js';
@@ -20,7 +20,7 @@ import { getMqStats } from './mqReader.js';
 import { execFile } from 'child_process';
 import { createReadStream, readFileSync, writeFileSync, readdirSync, existsSync, statSync, mkdirSync, rmSync } from 'fs';
 import { join, dirname, extname, basename, resolve, sep } from 'path';
-import { homedir, userInfo } from 'os';
+import { homedir, userInfo, networkInterfaces, hostname } from 'os';
 import { fileURLToPath } from 'url';
 import { ALL_CLAUDE_HOOK_EVENTS, DENSITY_EVENTS, SESSION_STATUS, WS_TYPES } from './constants.js';
 import log from './logger.js';
@@ -44,8 +44,22 @@ function saveLastUsername(username: string): void {
   if (username) _lastUsedUsername = username;
 }
 
+// Build set of all addresses/hostnames that resolve to this machine.
+// Matches sshManager.ts approach so local-session detection is consistent.
+const LOCAL_HOSTS = new Set<string>(['localhost', '127.0.0.1', '::1', '0.0.0.0']);
+try {
+  const h = hostname();
+  LOCAL_HOSTS.add(h);
+  LOCAL_HOSTS.add(`${h}.local`); // macOS mDNS
+  const ifaces = networkInterfaces();
+  for (const addrs of Object.values(ifaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) LOCAL_HOSTS.add(addr.address);
+  }
+} catch { /* ignore — hardcoded fallback is sufficient */ }
+
 function isLocalHost(host: string): boolean {
-  return !host || host === 'localhost' || host === '127.0.0.1' || host === '::1';
+  return !host || LOCAL_HOSTS.has(host);
 }
 
 // ---- Zod Validation Schemas ----
@@ -80,6 +94,7 @@ const terminalCreateSchema = z.object({
   sessionTitle: z.string().max(500).optional(),
   label: z.string().optional(),
   enableOpsTerminal: z.boolean().optional(),
+  forceNew: z.boolean().optional(),
 });
 
 const tmuxSessionsSchema = z.object({
@@ -115,6 +130,10 @@ const accentColorSchema = z.object({
   color: z.string().min(1).max(50),
 });
 
+const characterModelSchema = z.object({
+  model: z.string().min(1).max(50),
+});
+
 const summarizeSchema = z.object({
   context: z.string().min(1),
   promptTemplate: z.string().optional(),
@@ -615,6 +634,14 @@ router.put('/sessions/:id/accent-color', (req: Request, res: Response) => {
   res.json({ ok: true });
 });
 
+// Update session character model
+router.put('/sessions/:id/character-model', (req: Request, res: Response) => {
+  const body = validateBody(characterModelSchema, req.body, res);
+  if (!body) return;
+  setSessionCharacterModel(str(req.params.id), body.model);
+  res.json({ ok: true });
+});
+
 /**
  * Summarize session using Claude CLI.
  * The frontend sends { context, promptTemplate } from IndexedDB data.
@@ -716,8 +743,10 @@ router.post('/terminals', async (req: Request, res: Response) => {
   if (!body) return;
 
   try {
-    const resolvedHost = body.host || 'localhost';
-    const username = body.username || getDefaultUsername() || (isLocalHost(resolvedHost) ? 'local' : null);
+    // Normalize any local address (IP, hostname, .local) to 'localhost' so that
+    // dedup matching, PTY creation, and stored sshHost are all consistent.
+    const resolvedHost = isLocalHost(body.host || '') ? 'localhost' : (body.host || 'localhost');
+    const username = body.username || getDefaultUsername() || (resolvedHost === 'localhost' ? 'local' : null);
     if (!username) {
       res.status(400).json({ success: false, error: 'username required — set it once in "+ NEW SESSION" and it will be reused' });
       return;
@@ -747,11 +776,14 @@ router.post('/terminals', async (req: Request, res: Response) => {
     }
 
     // Deduplicate: if an active session with matching config already exists, return it
-    const existing = findActiveSessionByConfig(config);
-    if (existing) {
-      log.info('api', `Deduplicated terminal creation — reusing session ${existing.sessionId} for ${resolvedHost}:${config.workingDir}`);
-      res.json({ ok: true, terminalId: existing.sessionId, deduplicated: true });
-      return;
+    // Skip deduplication when forceNew is explicitly requested (e.g. Quick session modal)
+    if (!body.forceNew) {
+      const existing = findActiveSessionByConfig(config);
+      if (existing) {
+        log.info('api', `Deduplicated terminal creation — reusing session ${existing.sessionId} for ${resolvedHost}:${config.workingDir}`);
+        res.json({ ok: true, terminalId: existing.sessionId, deduplicated: true, hasTerminal: !!existing.terminalId });
+        return;
+      }
     }
 
     const terminalId = await createTerminal(config, null);
@@ -1058,9 +1090,9 @@ const STREAMABLE_EXTENSIONS = new Set([
 ]);
 
 /** Directories to skip when listing. */
+// Always-hidden dirs (even when showHidden=true) — large/noisy dirs with no browsing value
 const HIDDEN_DIRS = new Set([
-  'node_modules', '.git', '.next', '.nuxt', '__pycache__', '.venv',
-  'venv', 'dist', 'build', '.cache', '.turbo', 'coverage', '.svelte-kit',
+  'node_modules', '__pycache__', 'venv', 'dist', 'build', 'coverage',
 ]);
 
 function isTextFile(name: string): boolean {
@@ -1121,11 +1153,12 @@ router.get('/files/list', (req: Request, res: Response) => {
     const entries = readdirSync(fullPath, { withFileTypes: true });
     const items: Array<{ name: string; type: 'dir' | 'file'; size?: number; mtime?: string }> = [];
 
+    const showHidden = str(req.query.showHidden) === 'true';
     for (const entry of entries) {
-      // Skip hidden dirs (but show hidden files like .env)
+      // Skip certain always-hidden dirs regardless of showHidden flag
       if (entry.isDirectory() && HIDDEN_DIRS.has(entry.name)) continue;
-      // Skip dot-prefixed directories (e.g. .git) but show dot files
-      if (entry.isDirectory() && entry.name.startsWith('.')) continue;
+      // Skip dot-prefixed directories unless showHidden is set
+      if (!showHidden && entry.isDirectory() && entry.name.startsWith('.')) continue;
 
       if (entry.isDirectory()) {
         try {
@@ -1245,11 +1278,33 @@ router.get('/files/stream', (req: Request, res: Response) => {
     };
     const contentType = mimeMap[fileExt] || 'application/octet-stream';
 
-    res.setHeader('Content-Type', contentType);
-    res.setHeader('Content-Length', stat.size);
     const safeName = basename(fullPath).replace(/[^a-zA-Z0-9._-]/g, '_');
     res.setHeader('Content-Disposition', `inline; filename="${safeName}"`);
 
+    // Video/audio: support HTTP Range requests so browsers can seek
+    const isMedia = contentType.startsWith('video/') || contentType.startsWith('audio/');
+    if (isMedia) {
+      res.setHeader('Accept-Ranges', 'bytes');
+      const rangeHeader = req.headers.range;
+      if (rangeHeader) {
+        const [startStr, endStr] = rangeHeader.replace(/bytes=/, '').split('-');
+        const start = parseInt(startStr, 10);
+        const end = endStr ? parseInt(endStr, 10) : stat.size - 1;
+        const chunkSize = end - start + 1;
+        res.status(206);
+        res.setHeader('Content-Range', `bytes ${start}-${end}/${stat.size}`);
+        res.setHeader('Content-Length', chunkSize);
+        res.setHeader('Content-Type', contentType);
+        const rangeStream = createReadStream(fullPath, { start, end });
+        rangeStream.pipe(res);
+        rangeStream.on('error', () => { if (!res.headersSent) res.status(500).json({ error: 'Stream error' }); });
+        return;
+      }
+    }
+
+    res.setHeader('Content-Type', contentType);
+    res.setHeader('Content-Length', stat.size);
+
     const stream = createReadStream(fullPath);
     stream.pipe(res);
     stream.on('error', () => {

package/server/fileIndexCache.ts

@@ -1,5 +1,6 @@
 // fileIndexCache.ts — Cached file index for fast fuzzy search
 import { readdir } from 'fs/promises';
+import { watch as fsWatch } from 'fs';
 import { join } from 'path';
 import log from './logger.js';
 
@@ -28,10 +29,13 @@ interface CachedIndex {
 
 const cache = new Map<string, CachedIndex>();
 const building = new Set<string>();
+const watchers = new Map<string, ReturnType<typeof fsWatch>>();
+const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
-const CACHE_TTL_MS = 30_000; // 30 seconds
+const CACHE_TTL_MS = 30_000; // 30 seconds (watcher keeps it fresh in practice)
 const MAX_ENTRIES = 50_000;
 const MAX_DEPTH = 10;
+const WATCHER_DEBOUNCE_MS = 300;
 
 /** Build the file index for a project root (async, non-blocking). */
 async function buildIndex(root: string): Promise<FileEntry[]> {
@@ -74,7 +78,10 @@ async function buildIndex(root: string): Promise<FileEntry[]> {
  */
 function ensureIndex(root: string): void {
   const cached = cache.get(root);
-  if (cached && Date.now() - cached.builtAt < CACHE_TTL_MS) return;
+  if (cached && Date.now() - cached.builtAt < CACHE_TTL_MS) {
+    startWatcher(root);
+    return;
+  }
   if (building.has(root)) return;
 
   building.add(root);
@@ -82,6 +89,7 @@ function ensureIndex(root: string): void {
     .then(entries => {
       cache.set(root, { entries, builtAt: Date.now() });
       log.debug('file-index', `Built index for ${root}: ${entries.length} entries`);
+      startWatcher(root);
     })
     .catch(err => {
       log.error('file-index', `Failed to build index for ${root}: ${err instanceof Error ? err.message : String(err)}`);
@@ -91,6 +99,30 @@ function ensureIndex(root: string): void {
     });
 }
 
+/** Start a recursive fs.watch on root to invalidate cache on any file change. */
+function startWatcher(root: string): void {
+  if (watchers.has(root)) return;
+  try {
+    const watcher = fsWatch(root, { recursive: true }, (_event, filename) => {
+      // Skip node_modules and hidden dirs for performance
+      if (filename && (filename.includes('node_modules') || filename.includes('/.git/'))) return;
+      const existing = debounceTimers.get(root);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(root, setTimeout(() => {
+        debounceTimers.delete(root);
+        cache.delete(root);
+        log.debug('file-index', `Cache invalidated for ${root} (file change: ${filename})`);
+      }, WATCHER_DEBOUNCE_MS));
+    });
+    watcher.on('error', () => {
+      watchers.delete(root);
+    });
+    watchers.set(root, watcher);
+  } catch {
+    // Recursive watch not supported on this platform/path — silently ignore
+  }
+}
+
 /** Score a fuzzy match. Higher = better. Returns -1 if no match. */
 function fuzzyScore(query: string, nameLower: string, pathLower: string): number {
   // Exact filename match
@@ -178,7 +210,7 @@ export function searchFiles(
   return { results: scored.slice(0, maxResults), indexing: false };
 }
 
-/** Invalidate cache for a project root. */
+/** Invalidate cache for a project root (watcher stays active). */
 export function invalidateCache(root: string): void {
   cache.delete(root);
 }

package/server/sessionStore.ts

@@ -508,6 +508,37 @@ export function handleEvent(hookData: HookPayload): HandleEventResult | null {
   const session = matchSession(hookData, sessions, pendingResume, pidToSession, projectSessionCounters);
   if (!session) return null;
 
+  // When a session is re-keyed (replacesId is set), absorb any CONNECTING session for the
+  // same path that was created by workspace auto-load. After server restart:
+  //   - Priority 0.5 re-keys the old ended session (keeping its stale terminalId)
+  //   - Workspace auto-load created a fresh CONNECTING session for the same path
+  //   - Without merging, the CONNECTING card persists as a duplicate
+  // By merging, the re-keyed session gets the fresh SSH terminal and the orphan is removed.
+  // Safe for Priority 1/2/3 re-keys too: those consume the CONNECTING session during re-key,
+  // so no orphan exists for the same path and the loop finds nothing to merge.
+  if (session.replacesId && cwd) {
+    const normalizedCwd = cwd.replace(/\/$/, '');
+    for (const [orphanKey, orphan] of sessions) {
+      if (
+        orphanKey !== session.sessionId &&
+        orphan.terminalId &&
+        orphan.status === SESSION_STATUS.CONNECTING &&
+        orphan.projectPath?.replace(/\/$/, '') === normalizedCwd
+      ) {
+        session.terminalId = orphan.terminalId;
+        if (orphan.opsTerminalId) session.opsTerminalId = orphan.opsTerminalId;
+        if (orphan.sshConfig) session.sshConfig = orphan.sshConfig;
+        if (orphan.sshHost) session.sshHost = orphan.sshHost;
+        if (orphan.sshCommand) session.sshCommand = orphan.sshCommand;
+        sessions.delete(orphanKey);
+        invalidateSessionsCache();
+        broadcastAsync({ type: WS_TYPES.SESSION_REMOVED, sessionId: orphanKey });
+        log.info('session', `Merged orphan CONNECTING terminal ${orphan.terminalId?.slice(0,8)} into re-keyed session ${session.sessionId?.slice(0,8)} (path=${normalizedCwd})`);
+        break;
+      }
+    }
+  }
+
   // Auto-revive sessions that were marked ended by ServerRestart but whose Claude process survived.
   // This happens when Claude runs in tmux/screen and keeps sending hooks after server restart.
   const REVIVABLE_EVENTS: Set<string> = new Set([
@@ -928,21 +959,24 @@ export async function createTerminalSession(terminalId: string, config: Terminal
 
   await broadcastAsync({ type: WS_TYPES.SESSION_UPDATE, session: { ...session } });
 
-  // Non-Claude CLIs (codex, gemini, etc.) don't send hooks — auto-transition to idle
+  // Auto-transition from connecting to idle if hooks don't arrive in time.
+  // Non-Claude CLIs: 3s (they never send hooks).
+  // Claude: 30s fallback — hooks should arrive via SessionStart, but if the
+  // session_id or path doesn't match (e.g. SSH remote path mismatch), the card
+  // would be stuck in connecting forever without this safety net.
   const command = config.command || 'claude';
-  if (!command.startsWith('claude')) {
-    setTimeout(async () => {
-      const s = sessions.get(terminalId);
-      if (s && s.status === (SESSION_STATUS.CONNECTING as string)) {
-        s.status = SESSION_STATUS.IDLE;
-        s.animationState = ANIMATION_STATE.IDLE;
-        s.emote = null;
-        s.model = command; // Show command name as model
-        await broadcastAsync({ type: WS_TYPES.SESSION_UPDATE, session: { ...s } });
-        log.info('session', `Auto-transitioned non-Claude session ${terminalId} to idle (${command})`);
-      }
-    }, 3000);
-  }
+  const connectingTimeout = command.startsWith('claude') ? 30_000 : 3_000;
+  setTimeout(async () => {
+    const s = sessions.get(terminalId);
+    if (s && s.status === (SESSION_STATUS.CONNECTING as string)) {
+      s.status = SESSION_STATUS.IDLE;
+      s.animationState = ANIMATION_STATE.IDLE;
+      s.emote = null;
+      if (!command.startsWith('claude')) s.model = command;
+      await broadcastAsync({ type: WS_TYPES.SESSION_UPDATE, session: { ...s } });
+      log.info('session', `Auto-transitioned session ${terminalId} to idle after connecting timeout (${command})`);
+    }
+  }, connectingTimeout);
 
   return session;
 }

package/server/sshManager.ts

@@ -7,7 +7,7 @@ import type { IPty, IDisposable } from 'node-pty';
 import { execFile, execSync } from 'child_process';
 import { readdirSync } from 'fs';
 import { join } from 'path';
-import { homedir, networkInterfaces } from 'os';
+import { homedir, networkInterfaces, hostname as osHostname } from 'os';
 import log from './logger.js';
 import type { Terminal, TerminalConfig, TerminalInfo, TmuxSessionInfo, SshKeyInfo } from '../src/types/terminal.js';
 import type { PendingLink } from '../src/types/session.js';
@@ -181,6 +181,9 @@ function resolveWorkDir(dir: string | undefined): string {
 // even when the user accesses the dashboard via a LAN IP (e.g. 192.168.x.x).
 const localAddresses = new Set<string>(['localhost', '127.0.0.1', '::1', '0.0.0.0']);
 try {
+  const h = osHostname();
+  localAddresses.add(h);
+  localAddresses.add(`${h}.local`); // macOS mDNS
   const ifaces = networkInterfaces();
   for (const addrs of Object.values(ifaces)) {
     if (!addrs) continue;
@@ -313,6 +316,44 @@ export function createTerminal(config: TerminalConfig, wsClient: WebSocket | nul
 
       log.info('pty', `Spawned ${local ? 'local' : `remote (${config.host})`} terminal ${terminalId} (pid: ${ptyProcess.pid})`);
 
+      // Auto-type SSH password when password auth is used.
+      // Watches PTY output for "password:" prompts and sends the stored password.
+      if (!local && config.password) {
+        const storedPassword = config.password;
+        let passwordBuffer = '';
+        let passwordAttempts = 0;
+        const maxAttempts = 2;
+        const passwordDisp = ptyProcess.onData((data: string) => {
+          passwordBuffer += data;
+          if (passwordBuffer.length > 4096) passwordBuffer = passwordBuffer.slice(-4096);
+          const stripped = passwordBuffer.replace(ANSI_ESC_RE, '').toLowerCase();
+          if (stripped.includes('password:') || stripped.includes('password for')) {
+            passwordAttempts++;
+            if (passwordAttempts > maxAttempts) {
+              log.error('pty', `SSH password rejected after ${maxAttempts} attempts for ${terminalId}`);
+              passwordDisp.dispose();
+              return;
+            }
+            // Small delay to ensure the SSH process is ready for input
+            setTimeout(() => {
+              const term = terminals.get(terminalId);
+              if (term?.pty) {
+                term.pty.write(storedPassword + '\r');
+                log.info('pty', `Auto-typed SSH password for ${terminalId} (attempt ${passwordAttempts})`);
+              }
+            }, 100);
+            // Reset buffer so we don't re-trigger on the same prompt
+            passwordBuffer = '';
+          }
+          // Stop watching after successful auth (shell prompt appears)
+          if (stripped.includes('last login') || SHELL_PROMPT_RE.test(stripped.split(/[\r\n]+/).filter(l => l.trim()).pop() || '')) {
+            passwordDisp.dispose();
+          }
+        });
+        // Safety cleanup — stop watching after 30s regardless
+        setTimeout(() => { passwordDisp.dispose(); }, 30000);
+      }
+
       // Detect when the shell is ready (prompt visible) before sending commands.
       // Local shells init in ~100-300ms; remote SSH can take seconds for key exchange.
       const shellReady = detectShellReady(ptyProcess, terminalId, local ? 2000 : 10000);
@@ -327,8 +368,12 @@ export function createTerminal(config: TerminalConfig, wsClient: WebSocket | nul
         shellReady,
       });
 
-      // Register pending link for session matching
-      pendingLinks.set(workDir, { terminalId, host: config.host || 'localhost', createdAt: Date.now() });
+      // Register pending link for session matching.
+      // Skip for ops terminals (command='') — they never run Claude so they
+      // must not overwrite the main terminal's pending link for the same workDir.
+      if (!skipAutoLaunch) {
+        pendingLinks.set(workDir, { terminalId, host: config.host || 'localhost', createdAt: Date.now() });
+      }
 
       // #19: Store disposables for proper cleanup on terminal close
       const disposables: IDisposable[] = [];

package/dist/client/assets/ProjectBrowserView-DB5IJ4IC.js

@@ -1 +0,0 @@
-import{z as o,k as s,A as e,P as r}from"./index-CCOZp8gY.js";function l(){const[t]=o(),a=t.get("path");if(!a)return s.jsx("div",{className:e.standalone,children:s.jsxs("div",{className:e.standaloneEmpty,children:["No project path specified. Use ",s.jsx("code",{children:"?path=/your/project"})," to open a project."]})});const n=a.split("/").filter(Boolean).pop()||a;return s.jsxs("div",{className:e.standalone,children:[s.jsxs("div",{className:e.standaloneHeader,children:[s.jsx("span",{className:e.standaloneTitle,children:n}),s.jsx("span",{className:e.standalonePath,children:a})]}),s.jsx("div",{className:e.standaloneContent,children:s.jsx(r,{projectPath:a})})]})}export{l as default};