@zgeoff/atc 0.1.12 → 1.0.1

package/src/{ui.ts → client/ui.ts}

@@ -1,9 +1,11 @@
-import type { AgentKind } from './agent-adapter';
+import type { AgentID } from '../agents/agent-adapter';
+import { PINNED_GROUP_KEY } from '../daemon/sessions';
+import type { SessionState } from '../daemon/sessions';
+import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 import { formatDir } from './dirs';
 import { formatOverlayAgentMark } from './format-overlay-agent-mark';
-import { RESET_INPUT_MODES } from './reset-input-modes';
-import { PINNED_GROUP_KEY } from './sessions';
-import type { SessionState } from './sessions';
+import { planVacatedRows } from './plan-vacated-rows';
+import type { BoxExtent } from './plan-vacated-rows';
 
 // The slice of a session the drawing layer needs; satisfied by both the
 // daemon's sessions and the wire descriptors a client mirrors.
@@ -119,12 +121,24 @@ interface Row {
   readonly width: number;
 }
 
+// The extent of the last box drawn, so the next draw can erase the rows a
+// shrinking or shifting box leaves behind. Erasing an already-blank row is a
+// no-op, so a stale extent after a full clear is harmless.
+let lastBoxExtent: BoxExtent | null = null;
+
 function drawBox(rowsList: readonly Row[]) {
   const boxWidth = Math.max(...rowsList.map((r) => r.width));
   const top = Math.max(1, Math.floor((rows() - 1 - rowsList.length) / 2));
   const left = Math.max(1, Math.floor((cols() - boxWidth) / 2));
+  const extent: BoxExtent = { top, height: rowsList.length };
   let buf = ansi.hideCursor;
 
+  for (const row of planVacatedRows(lastBoxExtent, extent)) {
+    buf += `${ansi.moveTo(row, 1)}${ESC}[2K`;
+  }
+
+  lastBoxExtent = extent;
+
   for (const [i, r] of rowsList.entries()) {
     buf += ansi.moveTo(top + i, left) + r.styled;
   }
@@ -163,13 +177,18 @@ export interface OverlaySessionView extends SessionView {
   readonly alive: boolean;
   readonly kind: 'pty' | 'headless';
   readonly resumable: boolean;
-  readonly agent: AgentKind;
+  readonly canEject: boolean;
+  readonly agent: AgentID;
   readonly pinned: boolean;
   readonly repoRoot: string;
 }
 
 export interface OverlayView {
   sessions: readonly OverlaySessionView[];
+
+  // The overlay column character per agent id, for the ids that do not use
+  // the built-in one.
+  agentMarks: Readonly<Record<AgentID, string>>;
   selected: number;
   confirmKill: boolean;
   filter: string | null;
@@ -209,8 +228,8 @@ export function drawOverlay(view: OverlayView) {
     const msg = truncate(s.lastMsg, msgWidth).padEnd(msgWidth);
     const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
     const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
-    const mark = formatOverlayAgentMark(s.agent);
-    const styledMark = mark === 'g' ? `${ESC}[90m${mark}${ESC}[0m` : mark;
+    const mark = formatOverlayAgentMark(s.agent, view.agentMarks);
+    const styledMark = mark === ' ' ? mark : `${ESC}[90m${mark}${ESC}[0m`;
     const body = `${name} ${state}${dir} ${msg}`;
     const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
 
@@ -269,7 +288,7 @@ export function buildOverlayHint(s: OverlaySessionView | undefined): string {
       actions.push('a ack');
     }
 
-    if (s.agent === 'claude') {
+    if (s.canEject) {
       actions.push('H headless');
     }
 

package/src/{attach-registry.ts → daemon/attach-registry.ts}

@@ -1,3 +1,5 @@
+import type { SessionID } from '../shared/session-id';
+
 export interface Dims {
   readonly cols: number;
   readonly rows: number;
@@ -10,16 +12,16 @@ export interface Dims {
  * the whole screen.
  */
 export class AttachRegistry<TClient> {
-  private readonly bySession = new Map<string, Map<TClient, Dims>>();
+  private readonly bySession = new Map<SessionID, Map<TClient, Dims>>();
 
-  attach(sessionID: string, client: TClient, dims: Dims): void {
+  attach(sessionID: SessionID, client: TClient, dims: Dims): void {
     const clients = this.bySession.get(sessionID) ?? new Map<TClient, Dims>();
 
     clients.set(client, dims);
     this.bySession.set(sessionID, clients);
   }
 
-  detach(sessionID: string, client: TClient): void {
+  detach(sessionID: SessionID, client: TClient): void {
     const clients = this.bySession.get(sessionID);
 
     clients?.delete(client);
@@ -29,8 +31,8 @@ export class AttachRegistry<TClient> {
     }
   }
 
-  detachAll(client: TClient): string[] {
-    const affected: string[] = [];
+  detachAll(client: TClient): SessionID[] {
+    const affected: SessionID[] = [];
 
     for (const [sessionID, clients] of this.bySession) {
       if (clients.delete(client)) {
@@ -45,15 +47,15 @@ export class AttachRegistry<TClient> {
     return affected;
   }
 
-  removeSession(sessionID: string): void {
+  removeSession(sessionID: SessionID): void {
     this.bySession.delete(sessionID);
   }
 
-  hasClient(sessionID: string, client: TClient): boolean {
+  hasClient(sessionID: SessionID, client: TClient): boolean {
     return this.bySession.get(sessionID)?.has(client) ?? false;
   }
 
-  updateDims(sessionID: string, client: TClient, dims: Dims): boolean {
+  updateDims(sessionID: SessionID, client: TClient, dims: Dims): boolean {
     const clients = this.bySession.get(sessionID);
 
     if (clients === undefined || !clients.has(client)) {
@@ -65,11 +67,11 @@ export class AttachRegistry<TClient> {
     return true;
   }
 
-  collectClients(sessionID: string): TClient[] {
+  collectClients(sessionID: SessionID): TClient[] {
     return [...(this.bySession.get(sessionID)?.keys() ?? [])];
   }
 
-  findEffectiveDims(sessionID: string): Dims | null {
+  findEffectiveDims(sessionID: SessionID): Dims | null {
     const clients = this.bySession.get(sessionID);
 
     if (clients === undefined || clients.size === 0) {

package/src/daemon/build-session-event.ts

@@ -0,0 +1,43 @@
+import { PROTOCOL_V } from '../protocol/protocol';
+import type { EventMsg } from '../protocol/protocol';
+import type { SessionID } from '../shared/session-id';
+import type { Session, SessionDescriptor, SessionEventKind, SessionManager } from './sessions';
+
+/**
+ * Builds the wire event for a session-manager notification, or null when the
+ * notification carries no descriptor to send: `added` and `state` fold in
+ * the current descriptor and skip emitting if the session is gone by the
+ * time the descriptor is collected.
+ */
+export function buildSessionEvent(
+  mgr: SessionManager,
+  kind: SessionEventKind,
+  s: Session,
+): EventMsg | null {
+  const builders: Record<SessionEventKind, () => EventMsg | null> = {
+    added: () => {
+      const session = findDescriptor(mgr, s.id);
+
+      return session === null ? null : { v: PROTOCOL_V, ev: 'session.added', session };
+    },
+    state: () => {
+      const session = findDescriptor(mgr, s.id);
+
+      return session === null ? null : { v: PROTOCOL_V, ev: 'session.state', session };
+    },
+    renamed: () => ({
+      v: PROTOCOL_V,
+      ev: 'session.renamed',
+      s: s.id,
+      name: s.name,
+      namedBy: s.namedBy,
+    }),
+    removed: () => ({ v: PROTOCOL_V, ev: 'session.removed', s: s.id }),
+  };
+
+  return builders[kind]();
+}
+
+function findDescriptor(mgr: SessionManager, id: SessionID): SessionDescriptor | null {
+  return mgr.collectDescriptors().find((x) => x.id === id) ?? null;
+}