@celilo/console-server 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/console-server",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "HTTP surface for the celilo web console. Serves the SPA and hosts the tsrpc API. Holds no database: it reaches celilo-mgr over the SSH remote API as a read-only principal.",
   "type": "module",
   "main": "./src/index.ts",

package/src/upstream.ts

@@ -28,7 +28,12 @@
  */
 
 import type { DisplayWriter } from '@celilo/cli-display';
-import { type RemoteTransport, runRemoteClient, sshTransportWith } from '@celilo/core';
+import {
+  type RemoteSession,
+  type RemoteTransport,
+  openRemoteSession,
+  sshTransportWith,
+} from '@celilo/core';
 
 /** Why a read could not be served. Every case is renderable; none is silence. */
 export type UnavailableReason =
@@ -65,6 +70,8 @@ export interface UpstreamOptions {
 /** Exit code the API uses for "this principal may not do that". */
 const EXIT_DENIED = 126;
 
+type RemoteOutcomeOf = Awaited<ReturnType<RemoteSession['run']>>;
+
 interface CacheEntry {
   /** When the value SETTLED. Meaningless while `pending`. */
   at: number;
@@ -82,6 +89,22 @@ export class Upstream {
   private readonly ttl: number;
   private readonly now: () => number;
 
+  /**
+   * One connection, reused across reads.
+   *
+   * `api-serve` is a persistent server and its start-up dominates a read: on
+   * celilo-mgr it greets at ~1.8s and then answers commands in 1.25s and 0.06s
+   * on the SAME connection. Opening a fresh one per read re-paid that every
+   * time, which is most of why a console panel cost 5-11s against a 15s client
+   * timeout.
+   *
+   * ONE session, not a pool: the server runs a single command at a time
+   * (`serve.ts` holds one `commandRunning` slot), so a pool would not raise
+   * throughput, only connection count — and connection count is exactly what
+   * celilo#921 was about.
+   */
+  private session: RemoteSession | null = null;
+
   constructor(private readonly options: UpstreamOptions) {
     this.ttl = options.cacheTtlMs ?? 2_000;
     this.now = options.now ?? Date.now;
@@ -154,6 +177,34 @@ export class Upstream {
     this.cache.clear();
   }
 
+  private ensureSession(): RemoteSession {
+    const live = this.session;
+    if (live !== null && !live.closed) return live;
+    const session = openRemoteSession(this.options.dest, {
+      openTransport: this.options.openTransport ?? sshTransportWith(this.options.identityFile),
+      // Reached only if celilo asks the console a question. Nothing here can
+      // answer one, so say so loudly rather than parking a request forever.
+      // Session-scoped now rather than per-command, so it cannot name the argv;
+      // the reason is the same for every command the console issues.
+      renderInterview: () => {
+        throw new UpstreamUnavailable(
+          'interview',
+          [],
+          'A command raised an interview question. The console has no responder and never invokes operations that can ask one.',
+        );
+      },
+      onBlocked: 'return',
+    });
+    this.session = session;
+    return session;
+  }
+
+  /** Drop the connection. The next read opens a fresh one. */
+  closeSession(): void {
+    this.session?.close();
+    this.session = null;
+  }
+
   private async runJson<T>(argv: readonly string[]): Promise<T> {
     const output = await this.runText(argv);
     try {
@@ -177,23 +228,14 @@ export class Upstream {
       isTTY: false,
     };
 
-    let outcome: Awaited<ReturnType<typeof runRemoteClient>>;
+    let outcome: RemoteOutcomeOf;
     try {
-      outcome = await runRemoteClient(this.options.dest, [...argv], {
-        openTransport: this.options.openTransport ?? sshTransportWith(this.options.identityFile),
-        out,
-        // Reached only if celilo asks the console a question. Nothing here can
-        // answer one, so say so loudly rather than parking a request forever.
-        renderInterview: () => {
-          throw new UpstreamUnavailable(
-            'interview',
-            argv,
-            `\`${argv.join(' ')}\` raised an interview question. The console has no responder and never invokes operations that can ask one.`,
-          );
-        },
-        onBlocked: 'return',
-      });
+      outcome = await this.ensureSession().run(argv, { out });
     } catch (error) {
+      // The connection is suspect once a read has thrown through it — the
+      // server may have restarted or the transport died mid-command. Drop it so
+      // the NEXT read reconnects instead of writing into a pipe nobody reads.
+      this.closeSession();
       if (error instanceof UpstreamUnavailable) throw error;
       throw new UpstreamUnavailable(
         'unreachable',