elanous 0.2.0 → 0.2.4

package/src/acp/server.ts

@@ -33,11 +33,10 @@ import type {
   NewSessionRequest, NewSessionResponse,
   LoadSessionRequest, LoadSessionResponse,
   PromptRequest, PromptResponse,
-  SetSessionModelRequest, SetSessionModelResponse,
+  SetSessionConfigOptionRequest, SetSessionConfigOptionResponse,
+  SessionConfigOption,
   CancelNotification,
   ContentBlock,
-  ModelInfo,
-  SessionModelState,
 } from '@agentclientprotocol/sdk';
 import { randomBytes } from 'node:crypto';
 import type { NormalizedAttachment } from './content-blocks.js';
@@ -113,6 +112,29 @@ import { setSessionTierOverride } from '../model-tier/session-override.js';
 
 export const ACP_SERVER_SELF_PERFORMER = 'elanous:self';
 
+// ACP SDK 1.x removed the session «model» API (`ModelInfo`·`SessionModelState`·`session/set_model`) in favour of
+// session config options — the model list is now a `select` option with category `model` (#21407 bumped the SDK).
+// These local shapes keep the tier catalog projection; `modelConfigOption` turns it into the 1.x wire shape.
+export interface ModelInfo { modelId: string; name: string; description?: string }
+export interface SessionModelState { availableModels: ModelInfo[]; currentModelId: string }
+export const ACP_MODEL_CONFIG_ID = 'model';
+
+/** Session model state as the ACP 1.x `configOptions` entry (a `select` in the `model` category). */
+export function modelConfigOption(state: SessionModelState): SessionConfigOption {
+  return {
+    id: ACP_MODEL_CONFIG_ID,
+    name: 'Model',
+    category: 'model',
+    type: 'select',
+    currentValue: state.currentModelId,
+    options: state.availableModels.map((model) => ({
+      value: model.modelId,
+      name: model.name,
+      ...(model.description ? { _meta: { description: model.description } } : {}),
+    })),
+  };
+}
+
 type AcpSessionModelCatalog = Readonly<Partial<Record<LlmTierProvider, Readonly<Partial<Record<ModelTier, LlmTierSpec>>>>>>;
 
 /** Projects the static LLM tier catalog into ACP's session-model shape. */
@@ -197,7 +219,7 @@ export interface AcpServerSession {
 }
 
 export interface AcpServerOptions {
-  /** Name reported back to the client in initialize(). Default 'monad-agent'. */
+  /** Name reported back to the client in initialize(). Default 'elanous-agent'. */
   agentName?: string;
   /** Version string reported. Default read from package.json if present. */
   agentVersion?: string;
@@ -209,6 +231,16 @@ export interface AcpServerOptions {
    *  receives the user message text and a push() for streaming back
    *  assistant chunks. When omitted, the server echoes the prompt. */
   runTurn?: (ctx: AcpTurnContext) => Promise<void>;
+  /** ACP standalone entry: require session cwd or an explicit boot default. */
+  requireSessionToolCwd?: boolean;
+  bootToolCwd?: string;
+  /** Test seam for exercising stdio EOF with controlled byte streams. */
+  stdioInput?: ReadableStream<Uint8Array>;
+  stdioOutput?: WritableStream<Uint8Array>;
+  /** Test seam for a slow session/new handler. */
+  beforeNewSession?: () => Promise<void>;
+  /** Stdio EOF drain deadline; defaults to 30 seconds. */
+  stdioDrainTimeoutMs?: number;
   /** Session MCP path runner. Defaults to the canonical Codex ACP turn runner;
    *  tests inject it to observe the exact per-session child arguments. */
   runCodexTurn?: (opts: Parameters<typeof runAcpTurn>[0]) => Promise<unknown>;
@@ -315,7 +347,7 @@ export interface AcpServerOptions {
    *  already accept an `onConnection` callback. The factory wraps
    *  that call so the server hands in its own handler.
    *
-   *  When omitted, stdio behavior is unchanged. */
+   *  When omitted, stdio is used (with EOF response draining). */
   transportFactory?: (onConnection: AcpConnectionHandler) => Promise<AcpTransportServer>;
   /** U4b — shutdown seam for transport mode. When the server is
    *  running over `transportFactory`, the serve loop waits on this
@@ -1371,7 +1403,14 @@ function wireAcpConnection(
     },
 
     async newSession(req: NewSessionRequest): Promise<NewSessionResponse> {
-      const cwd = req.cwd ?? process.cwd();
+      if (opts.beforeNewSession) await opts.beforeNewSession();
+      const sessionCwd = typeof req.cwd === 'string' && req.cwd.trim() ? req.cwd : undefined;
+      const cwd = opts.requireSessionToolCwd
+        ? sessionCwd ?? opts.bootToolCwd
+        : req.cwd ?? process.cwd();
+      if (!cwd) {
+        throw RequestError.invalidParams(undefined, 'cwd required: pass session/new cwd or start with --tool-cwd');
+      }
       const mcpServers = req.mcpServers ?? [];
       const codexArgs = buildAcpSessionCodexArgs(mcpServers);
       const forwardedServerCount = codexArgs.length === 0
@@ -1400,30 +1439,39 @@ function wireAcpConnection(
       //   ⚠️ `if (debug.enabled)` 로 감싸지 않는다 — 그건 핫패스 게이트라 운영에서 꺼져 있고,
       //      기존 `acp.peer-id` 가 그 뒤에 있어 안 보였다. 세션 lifecycle 은 저빈도라 항상 남긴다.
       debug.log('acp.session', 'new', { sessionId: record.id, cwd });
+      if (opts.requireSessionToolCwd) {
+        debug.log('acp.session', 'tool-cwd', { sessionId: record.id, cwd, source: sessionCwd ? 'session' : 'boot' });
+      }
       const models = deriveAcpSessionModelState();
       advertisedSessionModels.set(record.id, models);
-      return { sessionId: record.id, models };
+      return { sessionId: record.id, configOptions: [modelConfigOption(models)] };
     },
 
-    async unstable_setSessionModel(req: SetSessionModelRequest): Promise<SetSessionModelResponse> {
+    async setSessionConfigOption(req: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse> {
       const advertisedModels = advertisedSessionModels.get(req.sessionId);
       if (!ownedSessionIds.has(req.sessionId) || !advertisedModels) {
         throw RequestError.invalidParams(undefined, 'unknown or unadvertised session');
       }
-      const selected = advertisedModels.availableModels.find((model) => model.modelId === req.modelId);
-      if (!selected) {
+      if (req.configId !== ACP_MODEL_CONFIG_ID) {
+        throw RequestError.invalidParams(undefined, 'unknown config option');
+      }
+      const modelId = typeof req.value === 'string' ? req.value : undefined;
+      const selected = modelId ? advertisedModels.availableModels.find((model) => model.modelId === modelId) : undefined;
+      if (!modelId || !selected) {
         throw RequestError.invalidParams(undefined, 'unadvertised session model');
       }
-      const [, tier] = req.modelId.split(':', 3);
+      const [, tier] = modelId.split(':', 3);
       if (!tier) {
         throw RequestError.invalidParams(undefined, 'invalid session model');
       }
       setSessionTierOverride(req.sessionId, {
         llm: tier as ModelTier,
-        rationale: `ACP client selected ${selected.name} (${req.modelId})`,
+        rationale: `ACP client selected ${selected.name} (${modelId})`,
       });
-      debug.log('acp.session', 'model-selected', { sessionId: req.sessionId, modelId: req.modelId, tier });
-      return {};
+      const next: SessionModelState = { ...advertisedModels, currentModelId: modelId };
+      advertisedSessionModels.set(req.sessionId, next);
+      debug.log('acp.session', 'model-selected', { sessionId: req.sessionId, modelId, tier });
+      return { configOptions: [modelConfigOption(next)] };
     },
 
     /** M2.3 — adopt an EXISTING session id from a long-lived ledger
@@ -1446,15 +1494,28 @@ function wireAcpConnection(
       // `opts.hasSession` check below queries history, not the live
       // sessions map). Idempotency: a re-load by the same connection
       // simply re-adds itself to the same set — no double-init.
+      const sessionCwd = typeof req.cwd === 'string' && req.cwd.trim() ? req.cwd : undefined;
+      const cwd = opts.requireSessionToolCwd
+        ? sessionCwd ?? opts.bootToolCwd
+        : req.cwd ?? process.cwd();
       if (sessions.has(sessionId)) {
+        if (opts.requireSessionToolCwd && sessionCwd) {
+          sessions.get(sessionId)!.cwd = sessionCwd;
+          debug.log('acp.session', 'tool-cwd', { sessionId, cwd: sessionCwd, source: 'session' });
+        }
         registerPeer(sessionId);
         return {};
       }
       if (!opts.hasSession || !opts.hasSession(sessionId)) {
         throw new Error(`unknown session: ${sessionId}`);
       }
-      const cwd = req.cwd ?? process.cwd();
+      if (!cwd) {
+        throw RequestError.invalidParams(undefined, 'cwd required: pass session/load cwd or start with --tool-cwd');
+      }
       acpServerLoadSession(sessions, dualRole, sessionId, cwd);
+      if (opts.requireSessionToolCwd) {
+        debug.log('acp.session', 'tool-cwd', { sessionId, cwd, source: sessionCwd ? 'session' : 'boot' });
+      }
       // BACKLOG #2.5 — broadcast peer registration.
       registerPeer(sessionId);
       return {};
@@ -2028,8 +2089,8 @@ function wireAcpConnection(
      *  convention.
      *
      *  `terminal/spawn`  · params: { sessionId, terminalId?, cwd?, cols?, rows?, shell? }
-     *      → spawns a fresh PreviewTerminal + registers in the
-     *        web-terminal tap registry · returns terminalId
+     *      → attaches a live shell with the same ID across sessions, or
+     *        spawns and registers a new PreviewTerminal · returns terminalId
      *  `terminal/input`  · params: { sessionId, terminalId, data }
      *      → forwards UTF-8 bytes to PreviewTerminal.write()
      *  `terminal/resize` · params: { sessionId, terminalId, cols, rows }
@@ -2070,14 +2131,26 @@ function wireAcpConnection(
         const cols = typeof p.cols === 'number' && p.cols > 0 ? p.cols : 80;
         const rows = typeof p.rows === 'number' && p.rows > 0 ? p.rows : 24;
 
-        const { lookupPreviewTerminal, registerPreviewTerminalForWebTap } =
+        const { lookupPreviewTerminal, findPreviewTerminalsById,
+          registerPreviewTerminalForWebTap, unregisterPreviewTerminalForWebTap } =
           await import('../web-terminal/preview-tap-registry.js');
 
-        // Idempotent — returning the existing terminal lets the PWA
-        // re-mount cycle attach to a single live PTY instead of
-        // spawning duplicates per Strict Mode mount-cleanup-mount.
-        const existing = lookupPreviewTerminal(p.sessionId, tid);
+        // Preserve same-session idempotency; remove dead registrations before
+        // adopting a live shell or creating a replacement.
+        const sameSession = lookupPreviewTerminal(p.sessionId, tid);
+        const matches = findPreviewTerminalsById(tid);
+        for (const match of matches) {
+          if (!match.pt.isAlive) unregisterPreviewTerminalForWebTap(match.pt);
+        }
+        const adopted = matches.find((match) => match.pt.isAlive);
+        const existing = sameSession?.isAlive ? sameSession : adopted?.pt;
         if (existing) {
+          if (existing !== sameSession && adopted) {
+            registerPreviewTerminalForWebTap(existing, p.sessionId, tid, handle);
+            debug.log('webterm.acp', 'spawn.adopt', {
+              terminalId: tid, fromSessions: adopted.sessionIds, toSession: p.sessionId,
+            });
+          }
           // P4 — replay opt-in: xterm-headless 가 상주 보유한 현재 화면을
           // render()(뷰포트·SGR 보존)로 동봉. 스냅샷 실패는 attach 를 막지
           // 않는다(fail-soft).
@@ -2173,10 +2246,15 @@ function wireAcpConnection(
         }
         const { lookupPreviewTerminal } = await import('../web-terminal/preview-tap-registry.js');
         const pt = lookupPreviewTerminal(p.sessionId, p.terminalId);
-        if (!pt) return { delivered: false, reason: 'unknown_terminal' };
+        if (!pt) {
+          debug.log('webterm.acp', 'resize.miss', { sessionId: p.sessionId, terminalId: p.terminalId, cols: p.cols, rows: p.rows });
+          return { delivered: false, reason: 'unknown_terminal' };
+        }
         try { pt.resize(p.cols, p.rows); } catch (e) {
+          debug.log('webterm.acp', 'resize.error', { terminalId: p.terminalId, reason: String(e) });
           return { delivered: false, reason: String(e) };
         }
+        if (debug.enabled) debug.log('webterm.acp', 'resize.ok', { sessionId: p.sessionId, terminalId: p.terminalId, cols: p.cols, rows: p.rows });
         return { delivered: true, cols: p.cols, rows: p.rows };
       }
       if (method === 'terminal/list') {
@@ -3270,15 +3348,84 @@ function streamFromTransportConnection(
   return ndJsonStream(connection.writable, connection.readable);
 }
 
-/** Build an ndJsonStream wrapping Node's stdio. Exported as a helper
- *  only so tests can substitute a pair of Web streams. */
-async function createStdioStream(): Promise<ReturnType<typeof ndJsonStream>> {
+/** Adapt Node's stdio into Web byte streams for the stdio ACP path. */
+async function createStdioBytes(): Promise<{
+  input: ReadableStream<Uint8Array>;
+  output: WritableStream<Uint8Array>;
+}> {
   const { Readable, Writable } = await import('node:stream');
-  const stdinWeb = (Readable as unknown as { toWeb: (s: unknown) => ReadableStream<Uint8Array> })
+  const input = (Readable as unknown as { toWeb: (s: unknown) => ReadableStream<Uint8Array> })
     .toWeb(process.stdin);
-  const stdoutWeb = (Writable as unknown as { toWeb: (s: unknown) => WritableStream<Uint8Array> })
+  const output = (Writable as unknown as { toWeb: (s: unknown) => WritableStream<Uint8Array> })
     .toWeb(process.stdout);
-  return ndJsonStream(stdoutWeb, stdinWeb);
+  return { input, output };
+}
+
+/** Keep the SDK's input stream open after EOF until responses already received
+ *  have been written. Closing it earlier makes the SDK abort its handlers. */
+function drainStdioResponses(
+  stream: ReturnType<typeof ndJsonStream>,
+  timeoutMs: number,
+): ReturnType<typeof ndJsonStream> {
+  const pending = new Map<string, number>();
+  let releaseDrain: (() => void) | undefined;
+  let inputEnded = false;
+  let drainTimer: ReturnType<typeof setTimeout> | undefined;
+  const input = stream.readable.getReader();
+  const output = stream.writable.getWriter();
+  const readable = new ReadableStream<NonNullable<Awaited<ReturnType<typeof input.read>>['value']>>({
+    async pull(controller) {
+      const { done, value } = inputEnded
+        ? { done: true as const, value: undefined }
+        : await input.read();
+      if (!done) {
+        if (value && !Array.isArray(value) && 'method' in value && 'id' in value) {
+          const key = JSON.stringify(value.id);
+          pending.set(key, (pending.get(key) ?? 0) + 1);
+        }
+        controller.enqueue(value!);
+        return;
+      }
+      if (!inputEnded) {
+        inputEnded = true;
+        if (pending.size > 0) {
+          drainTimer = setTimeout(() => {
+            drainTimer = undefined;
+            releaseDrain?.();
+          }, timeoutMs);
+        }
+      }
+      while (pending.size > 0 && drainTimer) {
+        await new Promise<void>((resolve) => { releaseDrain = resolve; });
+        releaseDrain = undefined;
+      }
+      if (drainTimer) clearTimeout(drainTimer);
+      drainTimer = undefined;
+      controller.close();
+    },
+    async cancel(reason) {
+      if (drainTimer) clearTimeout(drainTimer);
+      drainTimer = undefined;
+      await input.cancel(reason);
+    },
+  });
+  const writable = new WritableStream<Parameters<typeof output.write>[0]>({
+    async write(message) {
+      await output.write(message);
+      if (message && !Array.isArray(message) && !('method' in message) && 'id' in message) {
+        const key = JSON.stringify(message.id);
+        const count = pending.get(key);
+        if (count !== undefined) {
+          if (count === 1) pending.delete(key);
+          else pending.set(key, count - 1);
+          if (pending.size === 0) releaseDrain?.();
+        }
+      }
+    },
+    async close() { await output.close(); },
+    async abort(reason) { await output.abort(reason); },
+  });
+  return { readable, writable };
 }
 
 /** Construct the server state + register method handlers. Returns a
@@ -3310,7 +3457,7 @@ export async function runAcpServer(opts: AcpServerOptions = {}): Promise<void> {
     sessionPeers,
     dualRole,
     nextSessionToken: mintAcpSessionToken,
-    agentName: opts.agentName ?? 'monad-agent',
+    agentName: opts.agentName ?? 'elanous-agent',
     agentVersion: opts.agentVersion ?? readPkgVersion(),
     opts,
   };
@@ -3456,11 +3603,21 @@ export async function runAcpServer(opts: AcpServerOptions = {}): Promise<void> {
     return;
   }
 
-  // Stdio path — single connection, runs until stdin closes.
-  const stream = await createStdioStream();
+  // Stdio path — EOF stops intake, but already received replies drain first.
+  const bytes = opts.stdioInput && opts.stdioOutput
+    ? { input: opts.stdioInput, output: opts.stdioOutput }
+    : await createStdioBytes();
+  const stream = drainStdioResponses(
+    ndJsonStream(bytes.output, bytes.input),
+    opts.stdioDrainTimeoutMs ?? 30_000,
+  );
   const conn = wireAcpConnection(stream, ctx);
   try {
     await conn.closed;
+    // The SDK closes its message stream on EOF but does not close the
+    // underlying byte sink. Flush and end stdout only after the replies.
+    const writer = bytes.output.getWriter();
+    try { await writer.close(); } finally { writer.releaseLock(); }
   } finally {
     acpServerDisposeSessions(sessions, dualRole);
     activeAcpBroadcaster = null;

package/src/agent/pty-binding.ts

@@ -11,7 +11,7 @@
 //   3. VW pane intent (`paneId`) travels with the handle so the
 //      slash-command caller (Step E) knows where to mount.
 //
-// This file deliberately does NOT touch `src/virtual-windows/**` —
+// This file deliberately stays independent of the display layer —
 // mounting a PTY into a VW pane is a display concern and belongs to
 // the consumer of the returned BoundAgent (slash wiring, VW tool,
 // etc.). Keeping the boundary clean lets AXON and IDX evolve