pi-app-server 0.1.0

package/dist/server-ui-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/server-ui-context.ts"],
+  "sourcesContent": ["/**\n * Server UI Context - implements ExtensionUIContext for remote clients.\n *\n * Extension UI requests (select, confirm, input, etc.) are:\n * 1. Broadcast to all subscribed clients via extension_ui_request event\n * 2. Tracked as pending requests in ExtensionUIManager\n * 3. Resolved when a client sends extension_ui_response command\n *\n * This enables skills, prompt templates, and custom tools that need user input\n * to work over the WebSocket/stdio transport.\n */\n\nimport type { ExtensionUIContext, TerminalInputHandler } from \"@mariozechner/pi-coding-agent\";\nimport type { ExtensionUIManager } from \"./extension-ui.js\";\nimport {\n  isSelectResponse,\n  isConfirmResponse,\n  isInputResponse,\n  isEditorResponse,\n} from \"./extension-ui.js\";\n\n/**\n * Create an ExtensionUIContext that routes UI requests to remote clients.\n *\n * @param sessionId The session ID for request routing\n * @param extensionUI The manager that tracks pending requests\n * @param broadcast Function to broadcast events to subscribers\n */\nexport function createServerUIContext(\n  sessionId: string,\n  extensionUI: ExtensionUIManager,\n  broadcast: (sessionId: string, event: any) => void\n): ExtensionUIContext {\n  return {\n    async select(\n      title: string,\n      options: string[],\n      opts?: { signal?: AbortSignal; timeout?: number }\n    ): Promise<string | undefined> {\n      const request = extensionUI.createPendingRequest(sessionId, \"select\", {\n        title,\n        options,\n        timeout: opts?.timeout,\n      });\n\n      // If limit reached, return undefined (no selection possible)\n      if (!request) return undefined;\n\n      extensionUI.broadcastUIRequest(sessionId, request.requestId, \"select\", {\n        title,\n        options,\n        timeout: opts?.timeout,\n      });\n\n      try {\n        const response = await raceWithAbortAndSignal(request.promise, opts?.signal, () =>\n          extensionUI.cancelRequest(request.requestId)\n        );\n        if (response.method === \"cancelled\") return undefined;\n        if (isSelectResponse(response)) return response.value;\n        return undefined;\n      } catch {\n        // Timeout or abort - return undefined (no selection)\n        return undefined;\n      }\n    },\n\n    async confirm(\n      title: string,\n      message: string,\n      opts?: { signal?: AbortSignal; timeout?: number }\n    ): Promise<boolean> {\n      const request = extensionUI.createPendingRequest(sessionId, \"confirm\", {\n        title,\n        message,\n        timeout: opts?.timeout,\n      });\n\n      // If limit reached, return false (not confirmed)\n      if (!request) return false;\n\n      extensionUI.broadcastUIRequest(sessionId, request.requestId, \"confirm\", {\n        title,\n        message,\n        timeout: opts?.timeout,\n      });\n\n      try {\n        const response = await raceWithAbortAndSignal(request.promise, opts?.signal, () =>\n          extensionUI.cancelRequest(request.requestId)\n        );\n        if (response.method === \"cancelled\") return false;\n        if (isConfirmResponse(response)) return response.confirmed;\n        return false;\n      } catch {\n        // Timeout or abort - return false (not confirmed)\n        return false;\n      }\n    },\n\n    async input(\n      title: string,\n      placeholder?: string,\n      opts?: { signal?: AbortSignal; timeout?: number }\n    ): Promise<string | undefined> {\n      const request = extensionUI.createPendingRequest(sessionId, \"input\", {\n        title,\n        placeholder,\n        timeout: opts?.timeout,\n      });\n\n      // If limit reached, return undefined (no input possible)\n      if (!request) return undefined;\n\n      extensionUI.broadcastUIRequest(sessionId, request.requestId, \"input\", {\n        title,\n        placeholder,\n        timeout: opts?.timeout,\n      });\n\n      try {\n        const response = await raceWithAbortAndSignal(request.promise, opts?.signal, () =>\n          extensionUI.cancelRequest(request.requestId)\n        );\n        if (response.method === \"cancelled\") return undefined;\n        if (isInputResponse(response)) return response.value;\n        return undefined;\n      } catch {\n        // Timeout or abort - return undefined\n        return undefined;\n      }\n    },\n\n    async editor(title: string, prefill?: string): Promise<string | undefined> {\n      const request = extensionUI.createPendingRequest(sessionId, \"editor\", {\n        title,\n        prefill,\n      });\n\n      // If limit reached, return undefined (no editor input possible)\n      if (!request) return undefined;\n\n      extensionUI.broadcastUIRequest(sessionId, request.requestId, \"editor\", {\n        title,\n        prefill,\n      });\n\n      try {\n        const response = await raceWithAbortAndSignal(\n          request.promise,\n          undefined, // editor doesn't typically use abort signal\n          () => extensionUI.cancelRequest(request.requestId)\n        );\n        if (response.method === \"cancelled\") return undefined;\n        if (isEditorResponse(response)) return response.value;\n        return undefined;\n      } catch {\n        // Timeout - return undefined\n        return undefined;\n      }\n    },\n\n    notify(message: string, type?: \"info\" | \"warning\" | \"error\"): void {\n      // Broadcast notification to all subscribers\n      broadcast(sessionId, {\n        type: \"extension_ui_request\",\n        requestId: `notify-${Date.now()}`, // Ephemeral, no response expected\n        method: \"notify\",\n        message,\n        notifyType: type ?? \"info\",\n      });\n    },\n\n    onTerminalInput(_handler: TerminalInputHandler): () => void {\n      // Terminal input not available in server mode\n      // Return a no-op unsubscribe function\n      return () => {};\n    },\n\n    setStatus(key: string, text: string | undefined): void {\n      // Broadcast status update to subscribers\n      broadcast(sessionId, {\n        type: \"extension_ui_request\",\n        requestId: `status-${key}-${Date.now()}`,\n        method: \"setStatus\",\n        key,\n        text,\n      });\n    },\n\n    setWorkingMessage(message?: string): void {\n      // Broadcast working message update\n      broadcast(sessionId, {\n        type: \"extension_ui_request\",\n        requestId: `working-${Date.now()}`,\n        method: \"setWorkingMessage\",\n        message,\n      });\n    },\n\n    setWidget(\n      key: string,\n      content: any,\n      options?: { placement?: \"aboveEditor\" | \"belowEditor\" }\n    ): void {\n      // Only support string[] content (not component factories)\n      // Component factories can't be serialized for remote clients\n      if (Array.isArray(content) || content === undefined) {\n        broadcast(sessionId, {\n          type: \"extension_ui_request\",\n          requestId: `widget-${key}-${Date.now()}`,\n          method: \"setWidget\",\n          key,\n          content,\n          placement: options?.placement,\n        });\n      }\n      // If content is a function (component factory), ignore it silently\n      // Remote clients can't render server-side components\n    },\n\n    setFooter(_factory: any): void {\n      // Custom footer not supported in server mode\n      // This would require Component serialization\n    },\n\n    setHeader(_factory: any): void {\n      // Custom header not supported in server mode\n    },\n\n    setTitle(title: string): void {\n      // Broadcast title update\n      broadcast(sessionId, {\n        type: \"extension_ui_request\",\n        requestId: `title-${Date.now()}`,\n        method: \"setTitle\",\n        title,\n      });\n    },\n\n    async custom<T>(_factory: any, _options?: any): Promise<T> {\n      // Custom components not supported in server mode\n      // Would require serializing component factories\n      throw new Error(\"Custom components are not supported in server mode\");\n    },\n\n    pasteToEditor(_text: string): void {\n      // Editor paste not available in server mode\n    },\n\n    setEditorText(_text: string): void {\n      // Editor text setting not available in server mode\n    },\n\n    getEditorText(): string {\n      // Editor not available in server mode\n      return \"\";\n    },\n\n    setEditorComponent(_factory: any): void {\n      // Custom editor not supported in server mode\n    },\n\n    // Theme methods - return stubs since themes are TUI-specific\n    get theme(): any {\n      return {\n        // Minimal theme stub for extensions that check theme properties\n        colors: {},\n        styles: {},\n      };\n    },\n\n    getAllThemes(): { name: string; path: string | undefined }[] {\n      // Themes not available in server mode\n      return [];\n    },\n\n    getTheme(_name: string): any {\n      return undefined;\n    },\n\n    setTheme(_theme: string | any): { success: boolean; error?: string } {\n      return { success: false, error: \"Themes not supported in server mode\" };\n    },\n\n    getToolsExpanded(): boolean {\n      return false;\n    },\n\n    setToolsExpanded(_expanded: boolean): void {\n      // Tool expansion state not tracked in server mode\n    },\n  };\n}\n\n/**\n * Race a promise against abort signal and optional timeout.\n * Calls onCancel if aborted or timed out.\n */\nasync function raceWithAbortAndSignal<T>(\n  promise: Promise<T>,\n  signal: AbortSignal | undefined,\n  onCancel: () => void\n): Promise<T> {\n  if (!signal) {\n    return promise;\n  }\n\n  return new Promise<T>((resolve, reject) => {\n    const abortHandler = () => {\n      onCancel();\n      reject(new Error(\"Aborted\"));\n    };\n\n    signal.addEventListener(\"abort\", abortHandler);\n\n    promise\n      .then((result) => {\n        signal.removeEventListener(\"abort\", abortHandler);\n        resolve(result);\n      })\n      .catch((error) => {\n        signal.removeEventListener(\"abort\", abortHandler);\n        reject(error);\n      });\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/server.d.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * pi-app-server - Session multiplexer for pi-coding-agent
+ *
+ * Exposes N independent AgentSessions through dual transports:
+ * - WebSocket on port 3141
+ * - stdio (JSON lines)
+ *
+ * The protocol IS the architecture.
+ */
+import { PiSessionManager } from "./session-manager.js";
+import { type AuthProvider } from "./auth.js";
+import { MetricsEmitter, type MetricsSink, type ThresholdConfig, type Alert } from "./metrics-index.js";
+import { type Logger, type LogLevel } from "./logger-index.js";
+export interface PiServerOptions {
+    /** Authentication provider (default: AllowAllAuthProvider) */
+    authProvider?: AuthProvider;
+    /** Metrics sink(s) for observability. Can be a single sink or CompositeSink. */
+    metricsSink?: MetricsSink;
+    /** Include MemorySink automatically for get_metrics command (default: true) */
+    includeMemoryMetrics?: boolean;
+    /** Logger for structured logging (default: ConsoleLogger with 'info' level) */
+    logger?: Logger;
+    /** Log level for default ConsoleLogger (ignored if logger is provided) */
+    logLevel?: LogLevel;
+    /** Alert thresholds for automatic monitoring (default: built-in thresholds) */
+    alertThresholds?: Record<string, ThresholdConfig>;
+    /** Called when an alert fires (default: console logging) */
+    onAlert?: (alert: Alert) => void | Promise<void>;
+    /** Called when an alert clears (optional) */
+    onAlertClear?: (alert: Alert) => void | Promise<void>;
+}
+export declare class PiServer {
+    private sessionManager;
+    private wss;
+    private stdinInterface;
+    private authProvider;
+    private serverStartTime;
+    private metrics;
+    private logger;
+    /** Memory sink for get_metrics command (if included) */
+    private memorySink;
+    /** Stdio backpressure state */
+    private stdioState;
+    constructor(options?: PiServerOptions);
+    start(port?: number): Promise<void>;
+    /**
+     * Check if server is shutting down.
+     */
+    isInShutdown(): boolean;
+    /**
+     * Get session manager for external access.
+     */
+    getSessionManager(): PiSessionManager;
+    /**
+     * Get metrics emitter for external access.
+     */
+    getMetrics(): MetricsEmitter;
+    /**
+     * Get logger for external access.
+     */
+    getLogger(): Logger;
+    /**
+     * Get memory sink metrics (for get_metrics command).
+     * Returns undefined if includeMemoryMetrics was false.
+     */
+    getMemoryMetrics(): Record<string, unknown> | undefined;
+    /**
+     * Graceful shutdown.
+     * 1. Stop accepting new connections
+     * 2. Broadcast shutdown notification
+     * 3. Drain in-flight commands
+     * 4. Close all WebSocket connections
+     * 5. Close stdin
+     * 6. Dispose all sessions
+     */
+    stop(timeoutMs?: number): Promise<void>;
+    private setupWebSocket;
+    private setupStdio;
+    private handleCommand;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EAAE,KAAK,YAAY,EAA0C,MAAM,WAAW,CAAC;AACtF,OAAO,EACL,cAAc,EACd,KAAK,WAAW,EAMhB,KAAK,eAAe,EACpB,KAAK,KAAK,EACX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,MAAM,EAAiB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAyO9E,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gFAAgF;IAChF,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,+EAA+E;IAC/E,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAClD,4DAA4D;IAC5D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,6CAA6C;IAC7C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAED,qBAAa,QAAQ;IACnB,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,GAAG,CAAgC;IAC3C,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,wDAAwD;IACxD,OAAO,CAAC,UAAU,CAA2B;IAC7C,+BAA+B;IAC/B,OAAO,CAAC,UAAU,CAIhB;gBAEU,OAAO,GAAE,eAAoB;IAoEnC,KAAK,CAAC,IAAI,GAAE,MAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDvD;;OAEG;IACH,YAAY,IAAI,OAAO;IAIvB;;OAEG;IACH,iBAAiB,IAAI,gBAAgB;IAIrC;;OAEG;IACH,UAAU,IAAI,cAAc;IAI5B;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;;OAGG;IACH,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAIvD;;;;;;;;OAQG;IACG,IAAI,CAAC,SAAS,SAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IA2FlE,OAAO,CAAC,cAAc;IAuJtB,OAAO,CAAC,UAAU;YAqEJ,aAAa;CAmC5B"}

package/dist/server.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+import * as readline from "readline";
+import { WebSocketServer, WebSocket } from "ws";
+import { PiSessionManager } from "./session-manager.js";
+import { getSessionId as getSessionIdFromCmd, isCreateSessionResponse } from "./types.js";
+import { AllowAllAuthProvider } from "./auth.js";
+import {
+  MetricsEmitter,
+  NoOpSink,
+  MemorySink,
+  CompositeSink,
+  MetricNames,
+  ThresholdAlertSink
+} from "./metrics-index.js";
+import { ConsoleLogger } from "./logger-index.js";
+const SERVER_VERSION = "0.1.0";
+const PROTOCOL_VERSION = "1.0.0";
+const DEFAULT_PORT = 3141;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 3e4;
+const BACKPRESSURE_THRESHOLD_BYTES = 64 * 1024;
+const BACKPRESSURE_CRITICAL_BYTES = 1024 * 1024;
+const _STDIO_BACKPRESSURE_THRESHOLD_BYTES = 256 * 1024;
+const HEARTBEAT_INTERVAL_MS = 30 * 1e3;
+const HEARTBEAT_TIMEOUT_MS = 10 * 1e3;
+function sendWithBackpressure(ws, data, options = {}) {
+  const { isCritical = false } = options;
+  if (ws.readyState !== WebSocket.OPEN) {
+    return { ok: false, reason: "closed" };
+  }
+  const buffered = ws.bufferedAmount;
+  if (buffered > BACKPRESSURE_CRITICAL_BYTES) {
+    try {
+      ws.close(1011, "Server overloaded - backpressure critical");
+    } catch {
+    }
+    return { ok: false, reason: "backpressure" };
+  }
+  if (buffered > BACKPRESSURE_THRESHOLD_BYTES && !isCritical) {
+    return { ok: false, reason: "backpressure" };
+  }
+  try {
+    ws.send(data);
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: "error",
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function sendWithStdioBackpressure(data, state, options = {}) {
+  const { isCritical = false } = options;
+  try {
+    const canWrite = process.stdout.write(data + "\n");
+    if (!canWrite) {
+      state.hasBackpressure = true;
+      if (!state.drainHandlerRegistered) {
+        state.drainHandlerRegistered = true;
+        process.stdout.once("drain", () => {
+          state.hasBackpressure = false;
+        });
+      }
+    }
+    return true;
+  } catch (error) {
+    if (isCritical) {
+      console.error(`[stdio] Critical message failed:`, error);
+    }
+    return false;
+  }
+}
+function startHeartbeat(ws, state) {
+  state.lastPongAt = Date.now();
+  state.waitingForPong = false;
+  state.cleanedUp = false;
+  state.heartbeatTimer = setInterval(() => {
+    if (state.cleanedUp || ws.readyState !== WebSocket.OPEN) {
+      stopHeartbeat(state);
+      return;
+    }
+    if (state.waitingForPong) {
+      const elapsed = Date.now() - state.lastPongAt;
+      console.error(`[WebSocket] No pong received after ${elapsed}ms, closing connection`);
+      stopHeartbeat(state);
+      try {
+        ws.close(1001, "Heartbeat timeout");
+      } catch {
+      }
+      return;
+    }
+    state.waitingForPong = true;
+    try {
+      ws.ping();
+    } catch {
+      stopHeartbeat(state);
+    }
+    state.pongTimeoutTimer = setTimeout(() => {
+      if (state.cleanedUp) return;
+      if (state.waitingForPong && ws.readyState === WebSocket.OPEN) {
+        console.error(
+          `[WebSocket] Pong timeout after ${HEARTBEAT_TIMEOUT_MS}ms, closing connection`
+        );
+        stopHeartbeat(state);
+        try {
+          ws.close(1001, "Heartbeat timeout");
+        } catch {
+        }
+      }
+    }, HEARTBEAT_TIMEOUT_MS);
+  }, HEARTBEAT_INTERVAL_MS);
+}
+function stopHeartbeat(state) {
+  state.cleanedUp = true;
+  if (state.heartbeatTimer) {
+    clearInterval(state.heartbeatTimer);
+    state.heartbeatTimer = null;
+  }
+  if (state.pongTimeoutTimer) {
+    clearTimeout(state.pongTimeoutTimer);
+    state.pongTimeoutTimer = null;
+  }
+  state.waitingForPong = false;
+}
+class PiServer {
+  sessionManager = new PiSessionManager();
+  wss = null;
+  stdinInterface = null;
+  authProvider;
+  serverStartTime = Date.now();
+  metrics;
+  logger;
+  /** Memory sink for get_metrics command (if included) */
+  memorySink = null;
+  /** Stdio backpressure state */
+  stdioState = {
+    hasBackpressure: false,
+    droppedCount: 0,
+    drainHandlerRegistered: false
+  };
+  constructor(options = {}) {
+    this.authProvider = options.authProvider ?? new AllowAllAuthProvider();
+    this.logger = options.logger ?? new ConsoleLogger({
+      level: options.logLevel ?? "info",
+      component: "pi-server"
+    });
+    const defaultAlertThresholds = {
+      [MetricNames.RATE_LIMIT_GENERATION_COUNTER]: {
+        info: 1e12,
+        // 1 trillion - start paying attention
+        warn: 1e14,
+        // 100 trillion - concerning
+        critical: 1e15
+        // 1 quadrillion - action needed
+      }
+    };
+    const includeMemory = options.includeMemoryMetrics ?? true;
+    const sinks = [];
+    if (options.metricsSink) {
+      sinks.push(options.metricsSink);
+    }
+    if (includeMemory) {
+      this.memorySink = new MemorySink({ maxEvents: 1e3 });
+      sinks.push(this.memorySink);
+    }
+    const baseSink = sinks.length > 0 ? new CompositeSink(sinks) : new NoOpSink();
+    const alertThresholds = options.alertThresholds ?? defaultAlertThresholds;
+    const onAlert = options.onAlert ?? ((alert) => {
+      const levelStr = `[${alert.level.toUpperCase()}]`;
+      if (alert.level === "critical") {
+        console.error(`${levelStr} ${alert.message}`);
+      } else {
+        console.log(`${levelStr} ${alert.message}`);
+      }
+    });
+    const alertSink = new ThresholdAlertSink({
+      sink: baseSink,
+      thresholds: alertThresholds,
+      onAlert,
+      onClear: options.onAlertClear,
+      maxAlertStates: 1e3
+    });
+    this.metrics = new MetricsEmitter({ sink: alertSink });
+    this.sessionManager.getGovernor().setMetrics(this.metrics);
+    if (this.memorySink) {
+      this.sessionManager.setMemoryMetricsProvider(() => this.memorySink.getMetrics());
+    }
+  }
+  async start(port = DEFAULT_PORT) {
+    this.wss = new WebSocketServer({ port });
+    this.setupWebSocket(this.wss);
+    await new Promise((resolve, reject) => {
+      const onListening = () => {
+        this.wss?.off("error", onError);
+        resolve();
+      };
+      const onError = (error) => {
+        this.wss?.off("listening", onListening);
+        reject(error);
+      };
+      this.wss?.once("listening", onListening);
+      this.wss?.once("error", onError);
+    }).catch((error) => {
+      throw new Error(
+        `Failed to start WebSocket server on port ${port}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    this.stdinInterface = this.setupStdio();
+    this.sessionManager.startSessionCleanup(36e5);
+    this.sessionManager.getGovernor().startPeriodicCleanup(3e5);
+    const readyEvent = {
+      type: "server_ready",
+      data: {
+        serverVersion: SERVER_VERSION,
+        protocolVersion: PROTOCOL_VERSION,
+        transports: ["websocket", "stdio"]
+      }
+    };
+    this.sessionManager.broadcast(JSON.stringify(readyEvent));
+    this.metrics.event(MetricNames.EVENT_SESSION_CREATED, { event: "server_ready" });
+    this.logger.info("Server started", {
+      version: SERVER_VERSION,
+      protocol: PROTOCOL_VERSION,
+      port,
+      transports: ["websocket", "stdio"]
+    });
+  }
+  /**
+   * Check if server is shutting down.
+   */
+  isInShutdown() {
+    return this.sessionManager.isInShutdown();
+  }
+  /**
+   * Get session manager for external access.
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
+  /**
+   * Get metrics emitter for external access.
+   */
+  getMetrics() {
+    return this.metrics;
+  }
+  /**
+   * Get logger for external access.
+   */
+  getLogger() {
+    return this.logger;
+  }
+  /**
+   * Get memory sink metrics (for get_metrics command).
+   * Returns undefined if includeMemoryMetrics was false.
+   */
+  getMemoryMetrics() {
+    return this.memorySink?.getMetrics();
+  }
+  /**
+   * Graceful shutdown.
+   * 1. Stop accepting new connections
+   * 2. Broadcast shutdown notification
+   * 3. Drain in-flight commands
+   * 4. Close all WebSocket connections
+   * 5. Close stdin
+   * 6. Dispose all sessions
+   */
+  async stop(timeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      timeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS;
+    }
+    if (this.sessionManager.isInShutdown()) {
+      return;
+    }
+    this.logger.info("Graceful shutdown initiated");
+    this.sessionManager.stopSessionCleanup();
+    this.sessionManager.getGovernor().stopPeriodicCleanup();
+    if (this.authProvider.dispose) {
+      try {
+        await Promise.resolve(this.authProvider.dispose());
+      } catch (error) {
+        this.logger.logError(
+          "Auth provider dispose failed",
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    }
+    if (this.wss) {
+      this.wss.close(() => {
+        this.logger.debug("WebSocket server closed (no new connections)");
+      });
+    }
+    if (this.stdinInterface) {
+      this.stdinInterface.close();
+      this.stdinInterface = null;
+      this.logger.debug("Stdin closed");
+    }
+    const result = await this.sessionManager.initiateShutdown(timeoutMs);
+    if (result.timedOut) {
+      this.logger.warn("Shutdown timed out", {
+        timeoutMs,
+        drained: result.drained,
+        pending: this.sessionManager.getInFlightCount()
+      });
+    } else {
+      this.logger.info("All in-flight commands completed", { count: result.drained });
+    }
+    if (this.wss) {
+      const clients = [...this.wss.clients];
+      this.logger.info("Closing WebSocket connections", { count: clients.length });
+      for (const ws of clients) {
+        try {
+          ws.close(1001, "Server shutting down");
+        } catch {
+        }
+      }
+    }
+    const disposeResult = this.sessionManager.disposeAllSessions();
+    this.logger.info("Sessions disposed", {
+      disposed: disposeResult.disposed,
+      failed: disposeResult.failed
+    });
+    const uptimeMs = Date.now() - this.serverStartTime;
+    this.metrics.gauge(MetricNames.SESSION_LIFETIME_SECONDS, Math.floor(uptimeMs / 1e3));
+    await this.metrics.flush();
+    this.logger.info("Shutdown complete", { uptimeMs });
+  }
+  // ==========================================================================
+  // WEBSOCKET TRANSPORT
+  // ==========================================================================
+  setupWebSocket(wss) {
+    wss.on("connection", async (ws, request) => {
+      const connResult = this.sessionManager.getGovernor().canAcceptConnection();
+      if (!connResult.allowed) {
+        this.logger.warn("Connection rejected", { reason: connResult.reason });
+        try {
+          ws.close(1013, connResult.reason);
+        } catch {
+        }
+        return;
+      }
+      const authContext = {
+        request,
+        websocket: {
+          remoteAddress: request.socket?.remoteAddress,
+          secure: request.socket?.encrypted ?? false
+        },
+        serverStartTime: this.serverStartTime,
+        connectionCount: this.sessionManager.getGovernor().getConnectionCount()
+      };
+      const authResult = await Promise.resolve(this.authProvider.authenticate(authContext));
+      if (!authResult.allowed) {
+        this.logger.warn("Authentication failed", { reason: authResult.reason });
+        try {
+          ws.close(1008, authResult.reason);
+        } catch {
+        }
+        return;
+      }
+      this.sessionManager.getGovernor().registerConnection();
+      this.metrics.counter(MetricNames.CONNECTIONS_TOTAL, 1);
+      this.metrics.gauge(
+        MetricNames.CONNECTIONS_ACTIVE,
+        this.sessionManager.getGovernor().getConnectionCount()
+      );
+      const heartbeatState = {
+        waitingForPong: false,
+        lastPongAt: Date.now(),
+        heartbeatTimer: null,
+        pongTimeoutTimer: null,
+        cleanedUp: false
+      };
+      const subscriber = {
+        send: (data) => {
+          sendWithBackpressure(ws, data, { isCritical: false });
+        },
+        subscribedSessions: /* @__PURE__ */ new Set()
+      };
+      const readyEvent = {
+        type: "server_ready",
+        data: {
+          serverVersion: SERVER_VERSION,
+          protocolVersion: PROTOCOL_VERSION,
+          transports: ["websocket", "stdio"]
+        }
+      };
+      sendWithBackpressure(ws, JSON.stringify(readyEvent), { isCritical: true });
+      this.sessionManager.addSubscriber(subscriber);
+      let cleanedUp = false;
+      const cleanupConnection = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        stopHeartbeat(heartbeatState);
+        this.sessionManager.removeSubscriber(subscriber);
+        this.sessionManager.getGovernor().unregisterConnection();
+        this.metrics.gauge(
+          MetricNames.CONNECTIONS_ACTIVE,
+          this.sessionManager.getGovernor().getConnectionCount()
+        );
+      };
+      startHeartbeat(ws, heartbeatState);
+      ws.on("pong", () => {
+        heartbeatState.waitingForPong = false;
+        heartbeatState.lastPongAt = Date.now();
+        if (heartbeatState.pongTimeoutTimer) {
+          clearTimeout(heartbeatState.pongTimeoutTimer);
+          heartbeatState.pongTimeoutTimer = null;
+        }
+      });
+      ws.on("message", async (data) => {
+        const sizeResult = this.sessionManager.getGovernor().canAcceptMessage(data.length);
+        if (!sizeResult.allowed) {
+          const errorResponse = {
+            type: "response",
+            command: "unknown",
+            success: false,
+            error: sizeResult.reason
+          };
+          sendWithBackpressure(ws, JSON.stringify(errorResponse), { isCritical: true });
+          return;
+        }
+        try {
+          const command = JSON.parse(data.toString());
+          await this.handleCommand(command, subscriber, (response) => {
+            sendWithBackpressure(ws, JSON.stringify(response), { isCritical: true });
+          });
+        } catch (error) {
+          const errorResponse = {
+            type: "response",
+            command: "unknown",
+            success: false,
+            error: error instanceof Error ? error.message : "Invalid JSON"
+          };
+          sendWithBackpressure(ws, JSON.stringify(errorResponse), { isCritical: true });
+        }
+      });
+      ws.on("close", () => {
+        cleanupConnection();
+      });
+      ws.on("error", (error) => {
+        console.error(`[WebSocket] Connection error:`, error);
+        cleanupConnection();
+      });
+    });
+  }
+  // ==========================================================================
+  // STDIO TRANSPORT
+  // ==========================================================================
+  setupStdio() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    const subscriber = {
+      send: (data) => {
+        if (!sendWithStdioBackpressure(data, this.stdioState, { isCritical: false })) {
+          this.stdioState.droppedCount++;
+        }
+      },
+      subscribedSessions: /* @__PURE__ */ new Set()
+    };
+    this.sessionManager.addSubscriber(subscriber);
+    rl.on("line", async (line) => {
+      const messageBytes = Buffer.byteLength(line, "utf8");
+      const sizeResult = this.sessionManager.getGovernor().canAcceptMessage(messageBytes);
+      if (!sizeResult.allowed) {
+        const errorResponse = {
+          type: "response",
+          command: "unknown",
+          success: false,
+          error: sizeResult.reason
+        };
+        sendWithStdioBackpressure(JSON.stringify(errorResponse), this.stdioState, {
+          isCritical: true
+        });
+        return;
+      }
+      try {
+        const command = JSON.parse(line);
+        await this.handleCommand(command, subscriber, (response) => {
+          sendWithStdioBackpressure(JSON.stringify(response), this.stdioState, {
+            isCritical: true
+          });
+        });
+      } catch (error) {
+        const errorResponse = {
+          type: "response",
+          command: "unknown",
+          success: false,
+          error: error instanceof Error ? error.message : "Invalid JSON"
+        };
+        sendWithStdioBackpressure(JSON.stringify(errorResponse), this.stdioState, {
+          isCritical: true
+        });
+      }
+    });
+    rl.on("close", () => {
+      this.sessionManager.removeSubscriber(subscriber);
+    });
+    return rl;
+  }
+  // ==========================================================================
+  // COMMAND HANDLING
+  // ==========================================================================
+  async handleCommand(command, subscriber, respond) {
+    const response = await this.sessionManager.executeCommand(command);
+    respond(response);
+    if (command.type === "switch_session" && response.success) {
+      const sessionId = getSessionIdFromCmd(command);
+      if (sessionId) {
+        this.sessionManager.subscribeToSession(subscriber, sessionId);
+      }
+    }
+    if (command.type === "create_session" && isCreateSessionResponse(response)) {
+      const broadcast = {
+        type: "session_created",
+        data: {
+          sessionId: response.data.sessionId,
+          sessionInfo: response.data.sessionInfo
+        }
+      };
+      this.sessionManager.broadcast(JSON.stringify(broadcast));
+    } else if (command.type === "delete_session" && response.success) {
+      const broadcast = {
+        type: "session_deleted",
+        data: { sessionId: getSessionIdFromCmd(command) }
+      };
+      this.sessionManager.broadcast(JSON.stringify(broadcast));
+    }
+  }
+}
+async function main() {
+  const portEnv = process.env.PI_SERVER_PORT;
+  const port = portEnv ? parseInt(portEnv, 10) : DEFAULT_PORT;
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    console.error(`Invalid PI_SERVER_PORT: "${portEnv}". Must be 1-65535.`);
+    process.exit(1);
+    return;
+  }
+  const server = new PiServer();
+  await server.start(port);
+  const handleShutdown = async (signal) => {
+    console.error(`
+[${signal}] Received, initiating shutdown...`);
+    await server.stop(DEFAULT_SHUTDOWN_TIMEOUT_MS);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => handleShutdown("SIGINT"));
+  process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+export {
+  PiServer
+};
+//# sourceMappingURL=server.js.map