polygram 0.9.0 → 0.10.0-rc.2

package/lib/process-manager.js

@@ -0,0 +1,391 @@
+/**
+ * ProcessManager — generic collection of `Process` instances.
+ *
+ * Holds Map<sessionKey, Process>. Doesn't know or care which concrete
+ * Process subclass it's holding. SdkProcess + TmuxProcess both
+ * implement the same `lib/process/process.js` interface.
+ *
+ * Per-session dispatch (send, kill, interrupt, etc.) just delegates
+ * to the Process. Collection logic (LRU eviction, killChat, shutdown)
+ * lives here.
+ *
+ * Weighted LRU per Phase 0 F-spike-2: tmux backend is ~10× SDK pm's
+ * RSS (545MB vs 50MB). We evict to keep Σ Process.cost ≤ budget
+ * rather than count ≤ cap. Default: SDK cost=1, tmux cost=3,
+ * budget=10 → "10 SDK | 3 tmux | mixed in between."
+ *
+ * Lifecycle callbacks (onInit, onClose, onStreamChunk, etc.) get wired
+ * to each Process's EventEmitter at spawn. Process emits, pm forwards
+ * to operator's callback.
+ *
+ * Phase 1 only (this file): SDK-only factory; ProcessManager behaviour
+ * matches the current `lib/sdk/process-manager.js` API exactly. After
+ * Phase 1 lands and tests pass, the old per-bot pm class is deleted.
+ *
+ * See `docs/0.10.0-process-manager-abstraction-plan.md` for the full
+ * design.
+ */
+
+'use strict';
+
+const DEFAULT_BUDGET = 10;        // total Σ cost (SDK cost=1, tmux cost=3)
+const DEFAULT_LRU_WAIT_MS = 300_000;
+
+// callback name → event name
+const CALLBACK_TO_EVENT = {
+  onInit:                       'init',
+  onClose:                      'close',
+  onResult:                     'result',
+  onStreamChunk:                'stream-chunk',
+  onToolUse:                    'tool-use',
+  onAssistantMessageStart:      'assistant-message-start',
+  onAutonomousAssistantMessage: 'autonomous-assistant-message',
+  onCompactBoundary:            'compact-boundary',
+  onQueueDrop:                  'queue-drop',
+  onThinking:                   'thinking',
+  // Tmux backend: TUI shows in-pane approval prompt. SDK backend
+  // uses canUseTool callback directly (no event). Polygram wires
+  // onApprovalRequired to route tmux prompts through the SAME
+  // approval card UI used by SDK's canUseTool flow.
+  onApprovalRequired:           'approval-required',
+};
+
+class ProcessManager {
+  /**
+   * @param {object} opts
+   * @param {(sessionKey: string, ctx: object) => Process} opts.processFactory
+   *   — required. Returns a Process instance (not yet started).
+   * @param {number} [opts.budget=10] — weighted LRU budget
+   * @param {object} [opts.db] — used for _logEvent (matches today's pm)
+   * @param {object} [opts.logger=console]
+   * @param {object} [opts.callbacks={}] — keys: onInit, onClose, ...
+   * @param {number} [opts.lruWaitMs] — how long getOrSpawn parks
+   *   when all entries are in-flight
+   */
+  constructor({
+    processFactory,
+    budget = DEFAULT_BUDGET,
+    db,
+    logger = console,
+    callbacks = {},
+    lruWaitMs = DEFAULT_LRU_WAIT_MS,
+  } = {}) {
+    if (typeof processFactory !== 'function') {
+      throw new TypeError('ProcessManager: processFactory function required');
+    }
+    this.processFactory = processFactory;
+    this.budget = budget;
+    this.db = db;
+    this.logger = logger;
+    this.callbacks = { ...callbacks };
+    this.lruWaitMs = lruWaitMs;
+    this.procs = new Map();           // sessionKey → Process
+    this._lruWaiters = [];            // [{ resolve, reject, timer }]
+    this._shuttingDown = false;
+  }
+
+  // ─── Introspection ───────────────────────────────────────────────
+
+  has(sessionKey) { return this.procs.has(sessionKey); }
+  get(sessionKey) { return this.procs.get(sessionKey) || null; }
+  keys() { return [...this.procs.keys()]; }
+  get size() { return this.procs.size; }
+
+  /**
+   * Current total cost across all live processes.
+   */
+  get totalCost() {
+    let sum = 0;
+    for (const p of this.procs.values()) {
+      if (!p.closed) sum += p.cost;
+    }
+    return sum;
+  }
+
+  // ─── Spawn + LRU ─────────────────────────────────────────────────
+
+  /**
+   * Returns the Process for sessionKey, spawning if absent.
+   * Evicts other processes (oldest non-in-flight first) to make room
+   * when adding a new Process would exceed budget.
+   *
+   * @param {string} sessionKey
+   * @param {object} spawnContext — passed through to processFactory + start()
+   */
+  async getOrSpawn(sessionKey, spawnContext) {
+    if (this._shuttingDown) throw new Error('shutdown');
+
+    const existing = this.procs.get(sessionKey);
+    if (existing && !existing.closed) return existing;
+
+    // Provisional new-process cost — ask the factory but don't start yet.
+    const newProc = this.processFactory(sessionKey, spawnContext);
+    const newCost = newProc.cost;
+
+    while (this.totalCost + newCost > this.budget) {
+      const evicted = this._evictLRU();
+      if (!evicted) {
+        // All entries in-flight — park.
+        await this._awaitLruSlot();
+        if (this._shuttingDown) {
+          try { await newProc.kill('shutdown'); } catch {}
+          throw new Error('shutdown');
+        }
+        // Loop again — budget may have freed up.
+      }
+    }
+
+    this._wireCallbacks(newProc);
+    this.procs.set(sessionKey, newProc);
+    newProc.lastUsedTs = Date.now();
+    try {
+      await newProc.start(spawnContext);
+    } catch (err) {
+      this.procs.delete(sessionKey);
+      throw err;
+    }
+    return newProc;
+  }
+
+  _evictLRU() {
+    let oldest = null;
+    let oldestKey = null;
+    for (const [k, p] of this.procs.entries()) {
+      if (p.inFlight) continue;
+      if (!oldest || (p.lastUsedTs || 0) < (oldest.lastUsedTs || 0)) {
+        oldest = p;
+        oldestKey = k;
+      }
+    }
+    if (!oldest) {
+      this._logEvent('lru-full', {
+        active: this.procs.size,
+        totalCost: this.totalCost,
+        budget: this.budget,
+      });
+      return false;
+    }
+    this._logEvent('evict', {
+      session_key: oldestKey,
+      cost: oldest.cost,
+      backend: oldest.backend,
+    });
+    oldest.kill('evict').catch(() => {});
+    this.procs.delete(oldestKey);
+    return true;
+  }
+
+  async _awaitLruSlot() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const idx = this._lruWaiters.findIndex((w) => w.resolve === resolve);
+        if (idx !== -1) this._lruWaiters.splice(idx, 1);
+        this._logEvent('lru-wait-timeout', { wait_ms: this.lruWaitMs });
+        reject(new Error(`lru wait timed out after ${this.lruWaitMs}ms`));
+      }, this.lruWaitMs);
+      this._lruWaiters.push({ resolve, reject, timer });
+      this._logEvent('lru-wait', {
+        active: this.procs.size,
+        totalCost: this.totalCost,
+        budget: this.budget,
+      });
+    });
+  }
+
+  _maybeSignalLruWaiter() {
+    const w = this._lruWaiters.shift();
+    if (w) { clearTimeout(w.timer); w.resolve(); }
+  }
+
+  // ─── Per-session dispatch ────────────────────────────────────────
+
+  async send(sessionKey, prompt, opts) {
+    const proc = this.procs.get(sessionKey);
+    if (!proc) throw new Error(`no process for sessionKey ${sessionKey}`);
+    proc.lastUsedTs = Date.now();
+    return proc.send(prompt, opts);
+  }
+
+  async kill(sessionKey, reason = 'kill') {
+    const proc = this.procs.get(sessionKey);
+    if (!proc) return false;
+    this.procs.delete(sessionKey);
+    try { await proc.kill(reason); } catch {}
+    this._maybeSignalLruWaiter();
+    return true;
+  }
+
+  async killChat(chatId) {
+    const targets = [];
+    const idStr = String(chatId);
+    for (const [sk, p] of this.procs.entries()) {
+      if (p.chatId === idStr) targets.push([sk, p]);
+    }
+    for (const [sk] of targets) this.procs.delete(sk);
+    const results = await Promise.allSettled(
+      targets.map(([_, p]) => p.kill('killChat')),
+    );
+    for (let i = 0; i < targets.length; i++) {
+      this._maybeSignalLruWaiter();
+    }
+    return results;
+  }
+
+  async shutdown() {
+    this._shuttingDown = true;
+    // Reject parked lru waiters.
+    for (const w of this._lruWaiters) {
+      clearTimeout(w.timer);
+      w.reject(new Error('shutdown'));
+    }
+    this._lruWaiters.length = 0;
+
+    const all = [...this.procs.values()];
+    this.procs.clear();
+    await Promise.allSettled(all.map((p) => p.kill('shutdown')));
+  }
+
+  // ─── Optional async — feature-detect at call site if needed ──────
+
+  /**
+   * Shared dispatch for the five optional async methods. Returns the
+   * Process method's value on success, `unsupportedDefault` when the
+   * Process is missing/closed OR throws UNSUPPORTED_OPERATION /
+   * NOT_IMPLEMENTED_YET. Other errors propagate.
+   */
+  async _invokeOptional(sessionKey, methodName, args, unsupportedDefault) {
+    const p = this.procs.get(sessionKey);
+    if (!p || p.closed) return unsupportedDefault;
+    try { return await p[methodName](...args); }
+    catch (err) {
+      if (err && (err.code === 'UNSUPPORTED_OPERATION' || err.code === 'NOT_IMPLEMENTED_YET')) {
+        return unsupportedDefault;
+      }
+      throw err;
+    }
+  }
+
+  async interrupt(sessionKey) {
+    return this._invokeOptional(sessionKey, 'interrupt', [], false);
+  }
+
+  async setModel(sessionKey, model) {
+    return this._invokeOptional(sessionKey, 'setModel', [model], false);
+  }
+
+  async applyFlagSettings(sessionKey, settings) {
+    return this._invokeOptional(sessionKey, 'applyFlagSettings', [settings], false);
+  }
+
+  async setPermissionMode(sessionKey, mode) {
+    return this._invokeOptional(sessionKey, 'setPermissionMode', [mode], false);
+  }
+
+  async resetSession(sessionKey, opts) {
+    const p = this.procs.get(sessionKey);
+    // No active process for this key — return no-op. Matches the
+    // pre-0.10.0 SDK pm semantic (`closed: false` = "we did not close
+    // anything"). Caller can distinguish "session was already gone"
+    // from "we just closed an active session."
+    if (!p) return { closed: false, drainedPendings: 0 };
+    try {
+      const result = await p.resetSession(opts);
+      // The Process's resetSession closes itself; remove from Map
+      // and signal LRU.
+      if (this.procs.get(sessionKey) === p) {
+        this.procs.delete(sessionKey);
+      }
+      this._maybeSignalLruWaiter();
+      return result;
+    } catch (err) {
+      if (err.code === 'UNSUPPORTED_OPERATION' || err.code === 'NOT_IMPLEMENTED_YET') {
+        const drained = p.drainQueue('RESET_SESSION');
+        await this.kill(sessionKey, 'reset');
+        return { closed: true, drainedPendings: drained };
+      }
+      throw err;
+    }
+  }
+
+  async getContextUsage(sessionKey) {
+    return this._invokeOptional(sessionKey, 'getContextUsage', [], null);
+  }
+
+  // ─── Optional sync hot-path — never throws (R1-F1) ───────────────
+
+  drainQueue(sessionKey, code = 'INTERRUPTED') {
+    const p = this.procs.get(sessionKey);
+    if (!p) return 0;
+    return p.drainQueue(code);
+  }
+
+  injectUserMessage(sessionKey, opts) {
+    const p = this.procs.get(sessionKey);
+    if (!p || p.closed) return false;
+    return p.injectUserMessage(opts);
+  }
+
+  steer(sessionKey, text, opts) {
+    const p = this.procs.get(sessionKey);
+    if (!p || p.closed) return false;
+    return p.steer(text, opts);
+  }
+
+  // ─── Internal helpers ────────────────────────────────────────────
+
+  /**
+   * For each callback in this.callbacks, register a listener on the
+   * Process that forwards the event payload to the callback. Wire
+   * the standard event names; Process subclasses are free to emit
+   * additional events that pm doesn't forward.
+   *
+   * Also subscribes to 'idle' (Process became inFlight=false) and
+   * 'close' (Process closed itself) so the pm can signal parked
+   * LRU waiters + remove from the Map.
+   */
+  _wireCallbacks(proc) {
+    for (const [cbName, eventName] of Object.entries(CALLBACK_TO_EVENT)) {
+      const fn = this.callbacks[cbName];
+      if (typeof fn !== 'function') continue;
+      proc.on(eventName, (...args) => {
+        try { fn(proc.sessionKey, ...args, proc); }
+        catch (err) {
+          this.logger.error?.(`[pm:${proc.label}] callback ${cbName} threw: ${err.message}`);
+        }
+      });
+    }
+    // Generic 'error' channel — log + forward via onError if provided.
+    proc.on('error', (err) => {
+      this.logger.error?.(`[pm:${proc.label}] process error: ${err.message}`);
+      if (typeof this.callbacks.onError === 'function') {
+        try { this.callbacks.onError(proc.sessionKey, err, proc); }
+        catch (e) { this.logger.error?.(`[pm:${proc.label}] onError threw: ${e.message}`); }
+      }
+    });
+    // 'idle': a turn completed and pendingQueue is empty. Signal any
+    // parked LRU waiter that a non-in-flight slot is available.
+    proc.on('idle', () => this._maybeSignalLruWaiter());
+    // 'close': process closed itself (iteration loop exited or
+    // _closeQuery returned). Remove from the Map + signal LRU.
+    proc.on('close', () => {
+      if (this.procs.get(proc.sessionKey) === proc) {
+        this.procs.delete(proc.sessionKey);
+      }
+      this._maybeSignalLruWaiter();
+    });
+  }
+
+  _logEvent(kind, detail) {
+    try {
+      this.db?.logEvent?.(kind, detail || {});
+    } catch (err) {
+      this.logger.error?.(`[pm] logEvent ${kind} failed: ${err.message}`);
+    }
+  }
+}
+
+module.exports = {
+  ProcessManager,
+  DEFAULT_BUDGET,
+  CALLBACK_TO_EVENT,
+};

package/lib/sdk/callbacks.js

@@ -118,7 +118,12 @@ function createSdkCallbacks({
     // but don't propagate.
     onAutonomousAssistantMessage: (sessionKey, msg /* , entry */) => {
       try {
-        const text = extractAssistantText(msg);
+        // Backend-shape normalization: SDK emits the raw SDKMessage
+        // (text is inside content[]); tmux emits a pre-extracted
+        // {text, sessionId, backend}. Prefer the normalized field
+        // when present; fall back to SDK extraction.
+        const text = (msg && typeof msg.text === 'string' && msg.text)
+          || extractAssistantText(msg);
         if (!text) return;
         const chatId = getChatIdFromKey(sessionKey);
         const threadIdRaw = getThreadIdFromKey(sessionKey);
@@ -171,11 +176,14 @@ function createSdkCallbacks({
       // fires AFTER compaction completes, leaving users confused
       // when nothing followed. Now: distinguish manual vs auto and
       // surface the compression ratio.
+      // Backend-shape normalization: SDK emits the raw SDKMessage
+      // with compact_metadata nested; tmux emits flat fields. Try
+      // top-level first (tmux), then nested (SDK).
       const meta = msg?.compact_metadata || {};
-      const trigger = meta.trigger;        // 'manual' | 'auto'
-      const preTokens = meta.pre_tokens;
-      const postTokens = meta.post_tokens;
-      const durationMs = meta.duration_ms;
+      const trigger = msg?.trigger ?? meta.trigger;             // 'manual' | 'auto'
+      const preTokens = msg?.pre_tokens ?? meta.pre_tokens;
+      const postTokens = msg?.post_tokens ?? meta.post_tokens;
+      const durationMs = msg?.duration_ms ?? meta.duration_ms;
       const fmtTok = (n) => {
         if (n == null) return null;
         if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;