@drisp/cli 0.5.11 → 0.5.13

package/dist/athena-gateway.js

@@ -2039,6 +2039,39 @@ function instantiateAdapter(sidecar) {
   return { ok: true, adapter: module.create(parsed.config, sidecar.instanceId) };
 }
 
+// src/gateway/channelReconcilePlan.ts
+function planChannelReconciliation(input) {
+  const actions = [];
+  for (const error2 of input.loadErrors) {
+    actions.push({
+      kind: "load-error",
+      id: pathIdFromSidecarPath(error2.path),
+      path: error2.path,
+      reason: error2.reason
+    });
+  }
+  if (input.unregisterStale) {
+    const desiredIds = new Set(
+      input.desired.map((sidecar) => sidecar.instanceId)
+    );
+    for (const id of input.currentChannelIds) {
+      if (desiredIds.has(id)) continue;
+      actions.push({ kind: "unregister-stale", id });
+    }
+  }
+  const currentIds = new Set(input.currentChannelIds);
+  for (const sidecar of input.desired) {
+    actions.push(
+      currentIds.has(sidecar.instanceId) ? { kind: "replace", sidecar } : { kind: "register", sidecar }
+    );
+  }
+  return { actions };
+}
+function pathIdFromSidecarPath(filePath) {
+  const base = filePath.split(/[\\/]/).pop() ?? filePath;
+  return base.endsWith(".json") ? base.slice(0, -".json".length) : base;
+}
+
 // src/gateway/channelSidecarReconciler.ts
 var ChannelSidecarReconciler = class {
   channelManager;
@@ -2056,124 +2089,120 @@ var ChannelSidecarReconciler = class {
     this.stderr = opts.stderr ?? ((message) => process.stderr.write(message));
   }
   async reconcile(opts) {
-    const results = [];
     const { sidecars, errors } = this.loadSidecars(this.home);
-    for (const err of errors) {
-      const id = pathIdFromSidecarPath(err.path);
-      results.push({
-        id,
-        ok: false,
-        action: "failed",
-        reason: err.reason
-      });
-      if (opts.logFailures) {
-        this.stderr(`athena-gateway: skipping ${err.path}: ${err.reason}
-`);
-      }
-    }
-    if (opts.unregisterStale) {
-      const sidecarIds = new Set(sidecars.map((sidecar) => sidecar.instanceId));
-      for (const channel of this.channelManager.listChannels()) {
-        if (sidecarIds.has(channel.id)) continue;
-        try {
-          await this.channelManager.unregister(channel.id, "shutdown");
-          results.push({
-            id: channel.id,
-            ok: true,
-            action: "unregistered"
-          });
-        } catch (err) {
-          const reason = errorReason(err);
-          results.push({
-            id: channel.id,
+    const plan = planChannelReconciliation({
+      desired: sidecars,
+      currentChannelIds: this.channelManager.listChannels().map((channel) => channel.id),
+      loadErrors: errors,
+      unregisterStale: opts.unregisterStale
+    });
+    const outcomes = [];
+    for (const action of plan.actions) {
+      outcomes.push(await this.executeAction(action));
+    }
+    for (const outcome of outcomes) {
+      if (!outcome.log) continue;
+      const enabled = outcome.log.stream === "err" ? opts.logFailures : opts.logRegistrations;
+      if (!enabled) continue;
+      const write = outcome.log.stream === "err" ? this.stderr : this.stdout;
+      write(outcome.log.message);
+    }
+    return { results: outcomes.map((outcome) => outcome.result) };
+  }
+  async executeAction(action) {
+    switch (action.kind) {
+      case "load-error":
+        return {
+          result: {
+            id: action.id,
             ok: false,
             action: "failed",
-            reason
-          });
-          if (opts.logFailures) {
-            this.stderr(
-              `athena-gateway: unregister ${channel.id} failed: ${reason}
+            reason: action.reason
+          },
+          log: {
+            stream: "err",
+            message: `athena-gateway: skipping ${action.path}: ${action.reason}
 `
-            );
           }
+        };
+      case "unregister-stale":
+        return this.executeUnregisterStale(action.id);
+      case "replace":
+        return this.executeApply(action.sidecar, true);
+      case "register":
+        return this.executeApply(action.sidecar, false);
+    }
+  }
+  async executeUnregisterStale(id) {
+    try {
+      await this.channelManager.unregister(id, "shutdown");
+      return { result: { id, ok: true, action: "unregistered" } };
+    } catch (err) {
+      const reason = errorReason(err);
+      return {
+        result: { id, ok: false, action: "failed", reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: unregister ${id} failed: ${reason}
+`
         }
-      }
+      };
     }
-    for (const sidecar of sidecars) {
-      const existed = this.channelManager.listChannels().some((channel) => channel.id === sidecar.instanceId);
-      if (existed) {
-        try {
-          await this.channelManager.unregister(sidecar.instanceId, "shutdown");
-        } catch (err) {
-          const reason = errorReason(err);
-          results.push({
-            id: sidecar.instanceId,
-            ok: false,
-            action: "failed",
-            reason
-          });
-          if (opts.logFailures) {
-            this.stderr(
-              `athena-gateway: unregister ${sidecar.instanceId} failed: ${reason}
+  }
+  async executeApply(sidecar, existed) {
+    const id = sidecar.instanceId;
+    if (existed) {
+      try {
+        await this.channelManager.unregister(id, "shutdown");
+      } catch (err) {
+        const reason = errorReason(err);
+        return {
+          result: { id, ok: false, action: "failed", reason },
+          log: {
+            stream: "err",
+            message: `athena-gateway: unregister ${id} failed: ${reason}
 `
-            );
           }
-          continue;
-        }
+        };
       }
-      const built = this.instantiateAdapter(sidecar);
-      if (!built.ok) {
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason: built.reason
-        });
-        if (opts.logFailures) {
-          this.stderr(
-            `athena-gateway: ${sidecar.instanceId}: ${built.reason}
+    }
+    const built = this.instantiateAdapter(sidecar);
+    if (!built.ok) {
+      return {
+        result: { id, ok: false, action: "failed", reason: built.reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: ${id}: ${built.reason}
 `
-          );
         }
-        continue;
-      }
-      try {
-        await this.channelManager.register(
-          built.adapter,
-          sidecar.attachmentId !== void 0 ? { attachmentId: sidecar.attachmentId } : {}
-        );
-        results.push({
-          id: sidecar.instanceId,
-          ok: true,
-          action: existed ? "replaced" : "registered"
-        });
-        if (opts.logRegistrations) {
-          this.stdout(`athena-gateway: registered ${sidecar.instanceId}
-`);
+      };
+    }
+    try {
+      await this.channelManager.register(
+        built.adapter,
+        sidecar.attachmentId !== void 0 ? { attachmentId: sidecar.attachmentId } : {}
+      );
+      return {
+        result: { id, ok: true, action: existed ? "replaced" : "registered" },
+        log: {
+          stream: "out",
+          message: `athena-gateway: registered ${id}
+`
         }
-      } catch (err) {
-        const reason = errorReason(err);
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason
-        });
-        if (opts.logFailures) {
-          this.stderr(
-            `athena-gateway: register ${sidecar.instanceId} failed: ${reason}
+      };
+    } catch (err) {
+      const reason = errorReason(err);
+      return {
+        result: { id, ok: false, action: "failed", reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: register ${id} failed: ${reason}
 `
-          );
         }
-      }
+      };
     }
-    return { results };
   }
 };
-function pathIdFromSidecarPath(filePath) {
-  const base = filePath.split(/[\\/]/).pop() ?? filePath;
-  return base.endsWith(".json") ? base.slice(0, -".json".length) : base;
-}
 function errorReason(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -2248,7 +2277,14 @@ var RuntimeBindingStore = class {
       epoch,
       ...maybeLastRebindAt(lastRebindAt)
     };
-    const slot = existing ? { ...existing, runtime, binding: newBinding } : { runtime, binding: newBinding, staleTimer: null, staleSince: null };
+    const push = input.push ?? existing?.push ?? null;
+    const slot = existing ? { ...existing, runtime, binding: newBinding, push } : {
+      runtime,
+      binding: newBinding,
+      push,
+      staleTimer: null,
+      staleSince: null
+    };
     this.clearStaleTimerForSlot(slot);
     this.slots.set(key, slot);
     if (wasStale && staleSince !== null) {
@@ -2271,9 +2307,10 @@ var RuntimeBindingStore = class {
     this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: true });
   }
   /**
-   * Called when the transport connection closes.
-   * Returns the runtimeId if the close was for a current binding (caller should
-   * clear the push handle); returns null if the connectionId was not recognised.
+   * Called when the transport connection closes. Drops the slot's push handle
+   * (immediately deleting the slot when no grace period is configured, otherwise
+   * marking it stale). Returns the runtimeId if the close matched a current
+   * binding; returns null if the connectionId was not recognised.
    */
   notifyConnectionClosed(connectionId) {
     const entry = this.findSlotByConnectionId(connectionId);
@@ -2294,6 +2331,7 @@ var RuntimeBindingStore = class {
       this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: false });
       return runtimeId;
     }
+    slot.push = null;
     slot.staleSince = now;
     slot.staleTimer = setTimeout(() => {
       this.expireStaleBinding(key, runtimeId);
@@ -2328,6 +2366,28 @@ var RuntimeBindingStore = class {
     const entry = this.findSlotByConnectionId(connectionId);
     return entry ? entry.slot.runtime.runtimeId : null;
   }
+  /**
+   * Deliver a control-push envelope to the runtime occupying `key`. Returns
+   * false (and pushes nothing) when the slot is empty or its connection has
+   * already been lost.
+   */
+  pushTo(key, env) {
+    const slot = this.slots.get(key);
+    if (!slot || !slot.push) return false;
+    slot.push(env);
+    return true;
+  }
+  /**
+   * Reportable state for every slot — both attachment-keyed and the legacy
+   * fallback — so status reporting sees all registered runtimes.
+   */
+  snapshot() {
+    const entries = [];
+    for (const [key, slot] of this.slots) {
+      entries.push({ key, runtime: slot.runtime, binding: slot.binding });
+    }
+    return entries;
+  }
   /**
    * Returns the attachment slot key (or `undefined` for the legacy slot) that
    * holds the given runtime, or `null` if no slot does. Lets callers
@@ -2380,7 +2440,7 @@ var cachedVersion = null;
 function readVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.5.11";
+    const injected = "0.5.13";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;
@@ -2655,29 +2715,25 @@ function createDispatcher(deps) {
   return handle;
 }
 function runtimeStatusEntries(pipeline) {
-  const runtime = pipeline?.getCurrentRuntime();
-  if (!runtime || !pipeline) return [];
-  const binding = pipeline.getBinding();
-  return [
-    {
-      runtimeId: runtime.runtimeId,
-      defaultAgentId: runtime.defaultAgentId,
-      pid: runtime.pid,
-      registeredAt: runtime.registeredAt,
-      binding: binding?.state === "active" ? {
-        state: "active",
-        boundAt: binding.boundAt,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : binding?.state === "stale" ? {
-        state: "stale",
-        staleSince: binding.staleSince,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : { state: "none" },
-      pendingDispatchCount: pipeline.pendingDispatchCount()
-    }
-  ];
+  if (!pipeline) return [];
+  return pipeline.snapshotRuntimes().map(({ runtime, binding }) => ({
+    runtimeId: runtime.runtimeId,
+    defaultAgentId: runtime.defaultAgentId,
+    pid: runtime.pid,
+    registeredAt: runtime.registeredAt,
+    binding: binding?.state === "active" ? {
+      state: "active",
+      boundAt: binding.boundAt,
+      epoch: binding.epoch,
+      ...maybeLastRebindAt(binding.lastRebindAt)
+    } : binding?.state === "stale" ? {
+      state: "stale",
+      staleSince: binding.staleSince,
+      epoch: binding.epoch,
+      ...maybeLastRebindAt(binding.lastRebindAt)
+    } : { state: "none" },
+    pendingDispatchCount: pipeline.pendingDispatchCountFor(runtime.runtimeId)
+  }));
 }
 function ok(envelope, ts, payload) {
   return { request_id: envelope.request_id, ts, ok: true, payload };
@@ -2959,13 +3015,6 @@ function deriveSessionKey(loc) {
 
 // src/gateway/sessionRegistry.ts
 import { randomUUID } from "crypto";
-var UnknownDispatchError = class extends Error {
-  code = "unknown_dispatch";
-  constructor(id) {
-    super(`unknown dispatchId: ${id}`);
-    this.name = "UnknownDispatchError";
-  }
-};
 var SessionRegistry = class {
   dispatches = /* @__PURE__ */ new Map();
   idFactory;
@@ -2980,25 +3029,54 @@ var SessionRegistry = class {
       dispatchId,
       sessionKey: input.sessionKey,
       agentId: input.agentId,
+      runtimeId: input.runtimeId,
+      ...input.attachmentKey !== void 0 ? { attachmentKey: input.attachmentKey } : {},
       location: input.location,
       createdAt: this.now()
     };
     this.dispatches.set(dispatchId, entry);
     return entry;
   }
-  completeDispatch(dispatchId) {
+  /**
+   * Resolve a parked turn for the runtime claiming to complete it. The entry is
+   * consumed only when the claiming runtime matches the one the turn was
+   * dispatched to — a mismatched runtime cannot cancel or steal another
+   * runtime's turn, and an unknown id is reported rather than thrown.
+   */
+  completeDispatch(dispatchId, by) {
     const entry = this.dispatches.get(dispatchId);
     if (!entry) {
-      throw new UnknownDispatchError(dispatchId);
+      return { kind: "unknown" };
+    }
+    if (entry.runtimeId !== by.runtimeId) {
+      return { kind: "runtime_mismatch", entry };
     }
     this.dispatches.delete(dispatchId);
-    return entry;
+    return { kind: "completed", entry };
   }
   pendingDispatchCount() {
     return this.dispatches.size;
   }
-  clearDispatches() {
-    this.dispatches.clear();
+  /** Number of parked turns owned by the given runtime. */
+  pendingDispatchCountFor(runtimeId) {
+    let count = 0;
+    for (const entry of this.dispatches.values()) {
+      if (entry.runtimeId === runtimeId) count += 1;
+    }
+    return count;
+  }
+  /**
+   * Remove only the parked turns owned by the given runtime, leaving every other
+   * runtime's in-flight dispatches intact. Used when a single Registered runtime
+   * unregisters or its connection is lost — clearing the correct slot's turns
+   * without a global wipe.
+   */
+  clearDispatchesFor(runtimeId) {
+    for (const [dispatchId, entry] of this.dispatches) {
+      if (entry.runtimeId === runtimeId) {
+        this.dispatches.delete(dispatchId);
+      }
+    }
   }
 };
 
@@ -3125,8 +3203,6 @@ var DispatchPipeline = class {
   log;
   now;
   idFactory;
-  pushes = /* @__PURE__ */ new Map();
-  connectionToKey = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.bindingStore = new RuntimeBindingStore({
       gracePeriodMs: opts.gracePeriodMs,
@@ -3207,6 +3283,8 @@ var DispatchPipeline = class {
     const entry = this.registry.beginDispatch({
       sessionKey,
       agentId,
+      runtimeId: current.runtimeId,
+      ...key !== void 0 ? { attachmentKey: key } : {},
       location: inbound.location
     });
     this.pushDispatch(key, {
@@ -3218,9 +3296,7 @@ var DispatchPipeline = class {
     return { kind: "dispatched", dispatchId: entry.dispatchId, sessionKey };
   }
   pushDispatch(key, payload) {
-    const handle = this.pushes.get(key);
-    if (!handle) return;
-    handle.push({
+    this.bindingStore.pushTo(key, {
       push_id: this.idFactory(),
       ts: this.now(),
       kind: "session.dispatch.turn",
@@ -3235,17 +3311,9 @@ var DispatchPipeline = class {
       defaultAgentId: input.defaultAgentId,
       pid: input.pid,
       connectionId: input.connectionId,
+      push: input.push,
       ...input.attachmentId !== void 0 ? { attachmentId: input.attachmentId } : {}
     });
-    const previous = this.pushes.get(key);
-    if (previous && previous.connectionId !== input.connectionId) {
-      this.connectionToKey.delete(previous.connectionId);
-    }
-    this.pushes.set(key, {
-      connectionId: input.connectionId,
-      push: input.push
-    });
-    this.connectionToKey.set(input.connectionId, key);
     writeGatewayTrace(
       `pipeline registered runtime runtimeId=${input.runtimeId} connectionId=${input.connectionId}`
     );
@@ -3253,27 +3321,16 @@ var DispatchPipeline = class {
     return { registeredAt: result.registeredAt };
   }
   unregisterRuntime(runtimeId) {
-    const slot = this.findSlotByRuntimeId(runtimeId);
     this.bindingStore.unbind(runtimeId);
-    this.registry.clearDispatches();
-    if (slot) {
-      const handle = this.pushes.get(slot.key);
-      this.pushes.delete(slot.key);
-      if (handle) this.connectionToKey.delete(handle.connectionId);
-    }
+    this.registry.clearDispatchesFor(runtimeId);
     writeGatewayTrace(`pipeline unregistered runtime runtimeId=${runtimeId}`);
   }
   notifyConnectionClosed(connectionId) {
-    const key = this.connectionToKey.get(connectionId);
     const runtimeId = this.bindingStore.notifyConnectionClosed(connectionId);
     if (runtimeId === null) return;
     writeGatewayTrace(
       `pipeline runtime connection closed runtimeId=${runtimeId} connectionId=${connectionId}`
     );
-    if (key !== void 0 || this.pushes.has(key)) {
-      this.pushes.delete(key);
-      this.connectionToKey.delete(connectionId);
-    }
   }
   /**
    * Streaming run-event from a registered runtime to its outbound channel
@@ -3313,32 +3370,35 @@ var DispatchPipeline = class {
     if (!slot) {
       throw new Error("runtime mismatch on session.turn.complete");
     }
-    let entry;
-    try {
-      entry = this.registry.completeDispatch(payload.dispatchId);
-    } catch (err) {
-      if (err instanceof UnknownDispatchError) {
-        writeGatewayTrace(
-          `pipeline turn.complete unknown dispatchId=${payload.dispatchId}`
-        );
-        return { delivered: false };
-      }
-      throw err;
+    const completion = this.registry.completeDispatch(payload.dispatchId, {
+      runtimeId: payload.runtimeId
+    });
+    if (completion.kind === "unknown") {
+      writeGatewayTrace(
+        `pipeline turn.complete unknown dispatchId=${payload.dispatchId}`
+      );
+      return { delivered: false };
+    }
+    if (completion.kind === "runtime_mismatch") {
+      writeGatewayTrace(
+        `pipeline turn.complete runtime mismatch dispatchId=${payload.dispatchId} authorized=${completion.entry.runtimeId} claimed=${payload.runtimeId}`
+      );
+      return { delivered: false };
     }
-    const result = await this.sendOutbound(entry.location, payload);
+    const result = await this.sendOutbound(completion.entry.location, payload);
     writeGatewayTrace(
       `pipeline sendOutbound delivered dispatchId=${payload.dispatchId} providerMessageId=${result.providerMessageId}`
     );
     return { delivered: true, providerMessageId: result.providerMessageId };
   }
-  async sendOutbound(_parkedLocation, payload) {
+  async sendOutbound(parkedLocation, payload) {
     const out = {
-      location: payload.location,
+      location: parkedLocation,
       text: payload.text,
       idempotencyKey: payload.idempotencyKey
     };
     const result = await this.outboundDispatcher.dispatch(
-      payload.location.channelId,
+      parkedLocation.channelId,
       out
     );
     if (result.kind === "sent") return result.result;
@@ -3373,6 +3433,10 @@ var DispatchPipeline = class {
   getCurrentRuntime() {
     return this.bindingStore.getCurrent();
   }
+  /** Reportable state for every registered-runtime slot (legacy + attachment-keyed). */
+  snapshotRuntimes() {
+    return this.bindingStore.snapshot();
+  }
   getCurrentRuntimeByAttachment(attachmentId) {
     return this.bindingStore.getCurrentByAttachment(attachmentId);
   }
@@ -3388,6 +3452,9 @@ var DispatchPipeline = class {
   pendingDispatchCount() {
     return this.registry.pendingDispatchCount();
   }
+  pendingDispatchCountFor(runtimeId) {
+    return this.registry.pendingDispatchCountFor(runtimeId);
+  }
   pendingInboundCount() {
     return this.inboundQueue.size();
   }