@linkshell/gateway 0.4.49 → 0.4.51

package/src/relay.ts

@@ -109,6 +109,7 @@ type AgentConversationLike = {
   status?: string;
   provider?: string;
   title?: string;
+  lastMessagePreview?: string;
   lastActivityAt?: number;
   usage?: {
     inputTokens?: number;
@@ -120,6 +121,73 @@ type AgentConversationLike = {
   };
 };
 
+function truncateDetail(text: string, max = 72): string {
+  const line = text.replace(/\s+/g, " ").trim();
+  return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+}
+
+function commandOrPathFromToolInput(toolInput?: string): { command?: string; path?: string } {
+  if (!toolInput) return {};
+  try {
+    const parsed = JSON.parse(toolInput) as Record<string, unknown>;
+    if (parsed && typeof parsed === "object") {
+      return {
+        command: typeof parsed.command === "string" ? parsed.command : undefined,
+        path: typeof parsed.path === "string"
+          ? parsed.path
+          : typeof parsed.file_path === "string"
+            ? parsed.file_path
+            : undefined,
+      };
+    }
+  } catch {
+    const match = toolInput.match(/\$\s+([^\n]+)/);
+    if (match?.[1]) return { command: match[1].trim() };
+  }
+  return {};
+}
+
+/** List-line for a live permission request: "运行命令 · pnpm test". */
+function permissionAttentionDetail(p: {
+  toolName?: string;
+  toolInput?: string;
+  context?: string;
+}): string | undefined {
+  const { command, path } = commandOrPathFromToolInput(p.toolInput);
+  const name = (p.toolName ?? "").toLowerCase();
+  if (command) {
+    return truncateDetail(
+      /bash|shell|command/.test(name) || !p.toolName
+        ? `运行命令 · ${command}`
+        : `${p.toolName} · ${command}`,
+    );
+  }
+  if (path) {
+    const leaf = path.split("/").filter(Boolean).pop() ?? path;
+    if (/write|edit|multiedit/.test(name)) return truncateDetail(`改文件 · ${leaf}`);
+    if (/(^|_)read(_|$)|readfile/.test(name)) return truncateDetail(`读取 · ${leaf}`);
+    return truncateDetail(`${p.toolName || "文件"} · ${leaf}`);
+  }
+  if (p.context?.trim()) return truncateDetail(p.context.trim());
+  if (p.toolName) return truncateDetail(`需要授权 · ${p.toolName}`);
+  return undefined;
+}
+
+function conversationAttentionDetail(
+  conversation: AgentConversationLike | undefined,
+  status: string | undefined,
+  current?: { agentStatus?: string; agentDetail?: string },
+): string | null | undefined {
+  if (status === "waiting_permission") {
+    if (current?.agentStatus === "waiting_permission" && current.agentDetail) return undefined;
+    return conversation?.lastMessagePreview;
+  }
+  if (status === "running" || status === "error") {
+    return conversation?.lastMessagePreview ?? null;
+  }
+  return status ? null : undefined;
+}
+
 function pickConversationSummary(
   conversations: AgentConversationLike[],
   activeConversationId?: string,
@@ -169,14 +237,45 @@ function shouldPromoteTerminalStatus(status: string, current?: string): boolean
 
 function cacheAgentEnvelope(envelope: Envelope, sessions: SessionManager): void {
   try {
+    if (envelope.type === "agent.v2.conversation.list.result") {
+      const p = parseTypedPayload("agent.v2.conversation.list.result", envelope.payload);
+      const picked = pickConversationSummary(p.conversations);
+      const status = aggregateAgentStatus(p.conversations, picked?.status ?? "idle");
+      sessions.cacheAgentSummary(envelope.sessionId, {
+        status,
+        provider: picked?.provider,
+        conversationId: picked?.id,
+        title: picked?.title,
+        detail: conversationAttentionDetail(picked, status, sessions.get(envelope.sessionId)),
+        lastActivity: picked?.lastActivityAt ?? Date.now(),
+        usage: picked?.usage ?? null,
+      });
+      return;
+    }
+    if (envelope.type === "agent.v2.conversation.opened") {
+      const p = parseTypedPayload("agent.v2.conversation.opened", envelope.payload);
+      const conversation = p.conversation;
+      sessions.cacheAgentSummary(envelope.sessionId, {
+        status: conversation.status,
+        provider: conversation.provider,
+        conversationId: conversation.id,
+        title: conversation.title,
+        detail: conversationAttentionDetail(conversation, conversation.status, sessions.get(envelope.sessionId)),
+        lastActivity: conversation.lastActivityAt ?? Date.now(),
+        usage: conversation.usage ?? null,
+      });
+      return;
+    }
     if (envelope.type === "agent.v2.snapshot") {
       const p = parseTypedPayload("agent.v2.snapshot", envelope.payload);
       const picked = pickConversationSummary(p.conversations, p.activeConversationId);
+      const status = aggregateAgentStatus(p.conversations, picked?.status ?? "idle");
       sessions.cacheAgentSummary(envelope.sessionId, {
-        status: aggregateAgentStatus(p.conversations, picked?.status ?? "idle"),
+        status,
         provider: picked?.provider,
         conversationId: picked?.id ?? p.activeConversationId,
         title: picked?.title,
+        detail: conversationAttentionDetail(picked, status, sessions.get(envelope.sessionId)),
         lastActivity: picked?.lastActivityAt ?? Date.now(),
         usage: picked?.usage ?? null,
       });
@@ -184,12 +283,14 @@ function cacheAgentEnvelope(envelope: Envelope, sessions: SessionManager): void
     }
     if (envelope.type === "agent.v2.event") {
       const p = parseTypedPayload("agent.v2.event", envelope.payload);
+      const current = sessions.get(envelope.sessionId);
       if (p.conversation) {
         sessions.cacheAgentSummary(envelope.sessionId, {
           status: p.conversation.status,
           provider: p.conversation.provider,
           conversationId: p.conversation.id,
           title: p.conversation.title,
+          detail: conversationAttentionDetail(p.conversation, p.conversation.status, current),
           lastActivity: p.conversation.lastActivityAt,
           usage: p.conversation.usage ?? null,
         });
@@ -197,6 +298,7 @@ function cacheAgentEnvelope(envelope: Envelope, sessions: SessionManager): void
         sessions.cacheAgentSummary(envelope.sessionId, {
           status: p.patch.status,
           conversationId: p.conversationId,
+          detail: conversationAttentionDetail(undefined, p.patch.status, current),
           lastActivity: Date.now(),
         });
       }
@@ -207,6 +309,7 @@ function cacheAgentEnvelope(envelope: Envelope, sessions: SessionManager): void
       sessions.cacheAgentSummary(envelope.sessionId, {
         status: "waiting_permission",
         conversationId: p.conversationId,
+        detail: permissionAttentionDetail(p),
         lastActivity: Date.now(),
       });
       return;
@@ -236,6 +339,7 @@ function cacheAgentEnvelope(envelope: Envelope, sessions: SessionManager): void
       sessions.cacheAgentSummary(envelope.sessionId, {
         status: "waiting_permission",
         conversationId: p.agentSessionId,
+        detail: permissionAttentionDetail(p),
         lastActivity: Date.now(),
       });
       return;
@@ -274,6 +378,7 @@ function handleHostMessage(
 ): void {
   if (agentV2MessageRoute(envelope.type) === "host_to_client") {
     cacheAgentEnvelope(envelope, sessions);
+    sessions.bufferAgentEnvelope(session.id, envelope);
     broadcastToClients(session, envelope);
     return;
   }
@@ -463,6 +568,7 @@ function handleClientMessage(
       for (const statusMsg of statusReplay) {
         socket.send(serializeEnvelope(statusMsg));
       }
+      replayAgentToSocket(socket, session.id, sessions);
       // Also forward resume to host so it can fill gaps beyond gateway buffer.
       sendToHost(session, session.machineId
         ? {
@@ -550,6 +656,19 @@ function broadcastToClients(
   }
 }
 
+/** Replay the last agent snapshot + recent host→client agent envelopes. */
+export function replayAgentToSocket(
+  socket: WebSocket,
+  sessionId: string,
+  sessions: SessionManager,
+): void {
+  if (socket.readyState !== socket.OPEN) return;
+  for (const envelope of sessions.getAgentReplay(sessionId)) {
+    if (socket.bufferedAmount > MAX_CLIENT_BUFFER_BYTES) break;
+    socket.send(serializeEnvelope(envelope));
+  }
+}
+
 function sendToHost(
   session: ReturnType<SessionManager["get"]> & {},
   envelope: Envelope,

package/src/sessions.ts

@@ -36,6 +36,8 @@ export interface Session {
   agentProvider: string | undefined;
   agentConversationId: string | undefined;
   agentTitle: string | undefined;
+  // Short "what it's doing / asking" line for the session list.
+  agentDetail: string | undefined;
   agentLastActivity: number | undefined;
   // Latest token/context usage for the picked conversation (for at-a-glance
   // display on the session list, without opening the console).
@@ -44,6 +46,10 @@ export interface Session {
   // on-disk transcripts). Sent automatically on connect; shown as summary cards
   // on the session list page without entering the console.
   agentUsageReport: unknown | undefined;
+  // Last agent.v2.snapshot + recent host→client agent envelopes, so a
+  // reconnecting console can catch up without waiting on the host.
+  lastAgentSnapshot: Envelope | undefined;
+  agentReplay: Envelope[];
 }
 
 export interface AgentUsageSummary {
@@ -57,6 +63,7 @@ export interface AgentUsageSummary {
 
 const OUTPUT_BUFFER_CAPACITY = 200;
 const OUTPUT_BUFFER_MAX_BYTES = 8 * 1024 * 1024; // 8MB per terminal buffer
+const AGENT_REPLAY_CAPACITY = 80;
 const HOST_RECONNECT_WINDOW = 60_000; // 60s
 const CLEANUP_INTERVAL = 30_000;
 
@@ -74,11 +81,17 @@ function approxEnvelopeBytes(envelope: Envelope): number {
 export class SessionManager {
   private sessions = new Map<string, Session>();
   private cleanupTimer: ReturnType<typeof setInterval>;
+  /** Fired when host liveness or visible agent summary fields change. */
+  onPresenceChange?: (session: Session) => void;
 
   constructor() {
     this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL);
   }
 
+  private emitPresence(session: Session): void {
+    this.onPresenceChange?.(session);
+  }
+
   getOrCreate(sessionId: string): Session {
     let session = this.sessions.get(sessionId);
     if (!session) {
@@ -105,9 +118,12 @@ export class SessionManager {
         agentProvider: undefined,
         agentConversationId: undefined,
         agentTitle: undefined,
+        agentDetail: undefined,
         agentLastActivity: undefined,
         agentUsage: undefined,
         agentUsageReport: undefined,
+        lastAgentSnapshot: undefined,
+        agentReplay: [],
       };
       this.sessions.set(sessionId, session);
     }
@@ -124,6 +140,7 @@ export class SessionManager {
     session.state = "active";
     session.hostDisconnectedAt = undefined;
     session.lastActivity = Date.now();
+    this.emitPresence(session);
   }
 
   addClient(sessionId: string, device: ConnectedDevice): void {
@@ -143,6 +160,7 @@ export class SessionManager {
     session.host = undefined;
     session.state = "host_disconnected";
     session.hostDisconnectedAt = Date.now();
+    this.emitPresence(session);
     return { clients: session.clients };
   }
 
@@ -284,6 +302,7 @@ export class SessionManager {
       agentProvider: session.agentProvider ?? null,
       agentConversationId: session.agentConversationId ?? null,
       agentTitle: session.agentTitle ?? null,
+      agentDetail: session.agentDetail ?? null,
       agentLastActivity: session.agentLastActivity ?? null,
       agentUsage: session.agentUsage ?? null,
       agentUsageReport: session.agentUsageReport ?? null,
@@ -297,19 +316,65 @@ export class SessionManager {
       provider?: string | null;
       conversationId?: string | null;
       title?: string | null;
+      detail?: string | null;
       lastActivity?: number | null;
       usage?: AgentUsageSummary | null;
     },
-  ): void {
+  ): boolean {
     const session = this.sessions.get(sessionId);
-    if (!session) return;
+    if (!session) return false;
+    const prev = {
+      status: session.agentStatus,
+      provider: session.agentProvider,
+      conversationId: session.agentConversationId,
+      title: session.agentTitle,
+      detail: session.agentDetail,
+    };
     if (summary.status) session.agentStatus = summary.status;
     if (summary.provider !== undefined) session.agentProvider = summary.provider ?? undefined;
     if (summary.conversationId !== undefined) session.agentConversationId = summary.conversationId ?? undefined;
     if (summary.title !== undefined) session.agentTitle = summary.title ?? undefined;
+    if (summary.detail !== undefined) {
+      session.agentDetail = summary.detail ?? undefined;
+    } else if (summary.status && summary.status !== "waiting_permission") {
+      // Permission lines are only meaningful while waiting. A running/idle
+      // status without a new preview must not keep "运行命令 · …" around.
+      session.agentDetail = undefined;
+    }
     if (summary.lastActivity !== undefined) session.agentLastActivity = summary.lastActivity ?? undefined;
     if (summary.usage !== undefined) session.agentUsage = summary.usage ?? undefined;
     session.lastActivity = Date.now();
+    const changed =
+      prev.status !== session.agentStatus ||
+      prev.provider !== session.agentProvider ||
+      prev.conversationId !== session.agentConversationId ||
+      prev.title !== session.agentTitle ||
+      prev.detail !== session.agentDetail;
+    if (changed) this.emitPresence(session);
+    return changed;
+  }
+
+  bufferAgentEnvelope(sessionId: string, envelope: Envelope): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    if (envelope.type === "agent.v2.snapshot") {
+      session.lastAgentSnapshot = envelope;
+      session.agentReplay = [];
+      return;
+    }
+    session.agentReplay.push(envelope);
+    if (session.agentReplay.length > AGENT_REPLAY_CAPACITY) {
+      session.agentReplay.splice(0, session.agentReplay.length - AGENT_REPLAY_CAPACITY);
+    }
+  }
+
+  getAgentReplay(sessionId: string): Envelope[] {
+    const session = this.sessions.get(sessionId);
+    if (!session) return [];
+    return [
+      ...(session.lastAgentSnapshot ? [session.lastAgentSnapshot] : []),
+      ...session.agentReplay,
+    ];
   }
 
   setMetadata(