@linzumi/cli 0.0.102-beta → 0.0.103-beta

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.102-beta --version
+npx -y @linzumi/cli@0.0.103-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -3634,7 +3634,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     }
     dispatchPushedFrame(topic, name, ref, payload);
   };
-  const pushOnOpenSocket = (topic, event, payload, timeoutMs = pushTimeoutMs) => {
+  const pushOnOpenSocket = (topic, event, payload, timeoutMs = pushTimeoutMs, onSent) => {
     const websocket = state.websocket;
     if (websocket === void 0 || websocket.readyState !== WebSocket.OPEN) {
       return Promise.reject(phoenixPushErrors.socketNotOpen());
@@ -3655,6 +3655,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
       }, replyBudgetMs);
       pending.set(ref, { event, timer, resolve: resolve12, reject });
       websocket.send(JSON.stringify(frame));
+      onSent?.();
     });
   };
   const mergedJoinPayload = (topic, payloads) => {
@@ -3867,10 +3868,16 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
       }
     );
   });
-  const push = async (topic, event, payload) => {
+  const push = async (topic, event, payload, onSent) => {
     const deadlineMs = Date.now() + pushTimeoutMs;
     await awaitReady(event, deadlineMs);
-    return pushOnOpenSocket(topic, event, payload, deadlineMs - Date.now());
+    return pushOnOpenSocket(
+      topic,
+      event,
+      payload,
+      deadlineMs - Date.now(),
+      onSent
+    );
   };
   return {
     join: async (topic, payload, options2) => {
@@ -4548,10 +4555,15 @@ function createThreadOutbox(options) {
   let paused = false;
   let acceptingEnqueues = true;
   let stopped = false;
-  let drainPromise;
-  let wakeSleep;
   let closePromise;
   let journal;
+  const maxInFlightPushes = Math.max(
+    1,
+    Math.floor(options.maxInFlightPushes ?? 1)
+  );
+  let inFlightCount = 0;
+  let drainIdleWaiters = [];
+  let sendChainTail = Promise.resolve();
   const headEntry = () => queue[headIndex];
   const depth = () => queue.length - headIndex;
   const currentCounters = () => ({
@@ -4661,44 +4673,90 @@ function createThreadOutbox(options) {
       coalescible.delete(key);
     }
   };
-  const settleHead = (pending) => {
+  const applyHeadOutcome = (pending, outcome) => {
+    const entry = pending.entry;
+    switch (outcome.kind) {
+      case "ack": {
+        const builder = builders[entry.kind];
+        try {
+          builder?.onReply?.(entry.data, outcome.reply, context);
+        } catch (error) {
+          log2("outbox_on_reply_failed", {
+            threadKey,
+            entrySeq: entry.entrySeq,
+            kind: entry.kind,
+            error: errorMessage2(error)
+          });
+        }
+        journal?.appendAck(entry.entrySeq);
+        break;
+      }
+      case "skip": {
+        log2("outbox_entry_skipped", {
+          threadKey,
+          entrySeq: entry.entrySeq,
+          kind: entry.kind,
+          reason: outcome.reason
+        });
+        journal?.appendSkip(entry.entrySeq, outcome.reason);
+        break;
+      }
+      case "fail": {
+        if (entry.resolution === "must_ack") {
+          journal?.appendFail(entry.entrySeq);
+          try {
+            onPermanentFailure(entry, outcome.failure);
+          } catch (error) {
+            log2("outbox_permanent_failure_callback_failed", {
+              threadKey,
+              entrySeq: entry.entrySeq,
+              error: errorMessage2(error)
+            });
+          }
+        } else {
+          journal?.appendDrop(entry.entrySeq);
+        }
+        break;
+      }
+    }
     removeFromCoalescible(pending);
     advanceHead();
     notifyFlushWaiters();
   };
-  const settleFailure = (pending, failure) => {
+  const settleContiguousPrefix = () => {
+    while (true) {
+      const head = headEntry();
+      if (head === void 0 || head.outcome === void 0) {
+        return;
+      }
+      applyHeadOutcome(head, head.outcome);
+    }
+  };
+  const recordOutcome = (pending, outcome) => {
     const entry = pending.entry;
-    if (entry.resolution === "must_ack") {
-      totalPermanentFailures += 1;
-      log2("outbox_permanent_failure", {
-        threadKey,
-        entrySeq: entry.entrySeq,
-        kind: entry.kind,
-        attempts: entry.attempts,
-        error: failure.message
-      });
-      journal?.appendFail(entry.entrySeq);
-      try {
-        onPermanentFailure(entry, failure);
-      } catch (error) {
-        log2("outbox_permanent_failure_callback_failed", {
+    if (outcome.kind === "fail") {
+      if (entry.resolution === "must_ack") {
+        totalPermanentFailures += 1;
+        log2("outbox_permanent_failure", {
           threadKey,
           entrySeq: entry.entrySeq,
-          error: errorMessage2(error)
+          kind: entry.kind,
+          attempts: entry.attempts,
+          error: outcome.failure.message
+        });
+      } else {
+        totalDroppedBestEffort += 1;
+        log2("outbox_dropped_best_effort", {
+          threadKey,
+          entrySeq: entry.entrySeq,
+          kind: entry.kind,
+          attempts: entry.attempts,
+          error: outcome.failure.message
         });
       }
-    } else {
-      totalDroppedBestEffort += 1;
-      log2("outbox_dropped_best_effort", {
-        threadKey,
-        entrySeq: entry.entrySeq,
-        kind: entry.kind,
-        attempts: entry.attempts,
-        error: failure.message
-      });
-      journal?.appendDrop(entry.entrySeq);
     }
-    settleHead(pending);
+    pending.outcome = outcome;
+    pending.state = "queued";
   };
   const recordPushLatency = (latencyMs) => {
     if (pushLatencyWindow.length < outboxPushLatencyWindowSize) {
@@ -4708,136 +4766,180 @@ function createThreadOutbox(options) {
     }
     pushLatencyNextIndex = (pushLatencyNextIndex + 1) % outboxPushLatencyWindowSize;
   };
-  const sleep2 = (ms) => new Promise((resolve12) => {
-    const timer = setTimeout(() => {
-      wakeSleep = void 0;
-      resolve12();
-    }, ms);
-    wakeSleep = () => {
-      clearTimeout(timer);
-      wakeSleep = void 0;
+  const clearRetryTimer = (pending) => {
+    if (pending.retryTimer !== void 0) {
+      clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+    }
+  };
+  const notifyDrainIdle = () => {
+    if (inFlightCount > 0) {
+      return;
+    }
+    const waiters = drainIdleWaiters;
+    drainIdleWaiters = [];
+    for (const resolve12 of waiters) {
       resolve12();
-    };
-  });
-  const drainHeadEntry = async (pending) => {
+    }
+  };
+  const headInBackoff = () => {
+    const head = headEntry();
+    return head !== void 0 && head.outcome === void 0 && head.state === "queued" && head.retryTimer !== void 0;
+  };
+  const scheduleRetry = (pending, delayMs) => {
+    clearRetryTimer(pending);
+    pending.retryTimer = setTimeout(() => {
+      pending.retryTimer = void 0;
+      if (stopped || paused || pending.outcome !== void 0) {
+        return;
+      }
+      pumpWindow();
+    }, delayMs);
+    pending.retryTimer?.unref?.();
+  };
+  const pushEntry = async (pending) => {
     const entry = pending.entry;
-    while (!stopped) {
+    const sendTurn = sendChainTail;
+    let releaseSendChain = () => void 0;
+    sendChainTail = new Promise((resolve12) => {
+      releaseSendChain = resolve12;
+    });
+    let released = false;
+    const releaseSend = () => {
+      if (!released) {
+        released = true;
+        releaseSendChain();
+      }
+    };
+    pending.state = "pushing";
+    inFlightCount += 1;
+    try {
+      await sendTurn;
+      if (stopped || paused || pending.outcome !== void 0) {
+        pending.state = "queued";
+        releaseSend();
+        return;
+      }
       const builder = builders[entry.kind];
       if (builder === void 0) {
-        settleFailure(
-          pending,
-          new Error(`no outbox builder registered for kind ${entry.kind}`)
-        );
+        releaseSend();
+        recordOutcome(pending, {
+          kind: "fail",
+          failure: new Error(
+            `no outbox builder registered for kind ${entry.kind}`
+          )
+        });
         return;
       }
       let built;
       try {
         built = builder.build(entry.data, context);
       } catch (error) {
-        settleFailure(pending, toError(error));
+        releaseSend();
+        recordOutcome(pending, { kind: "fail", failure: toError(error) });
         return;
       }
       if ("skip" in built) {
-        log2("outbox_entry_skipped", {
+        releaseSend();
+        recordOutcome(pending, { kind: "skip", reason: built.reason });
+        return;
+      }
+      entry.attempts += 1;
+      await pushBuilt(pending, built, releaseSend);
+    } finally {
+      inFlightCount -= 1;
+    }
+  };
+  const pushBuilt = async (pending, built, releaseSend) => {
+    const entry = pending.entry;
+    const pushStartedAtMs = now();
+    try {
+      const reply = await options.push(
+        built.event,
+        built.payload,
+        built.timeoutMs,
+        releaseSend
+      );
+      releaseSend();
+      recordPushLatency(Math.max(0, now() - pushStartedAtMs));
+      totalAcked += 1;
+      recordOutcome(pending, { kind: "ack", reply });
+    } catch (error) {
+      releaseSend();
+      pending.state = "queued";
+      const failure = toError(error);
+      if (options.isRetryBudgetExempt?.(failure) === true) {
+        entry.attempts -= 1;
+        totalRetried += 1;
+        log2("outbox_push_connection_wait", {
           threadKey,
           entrySeq: entry.entrySeq,
           kind: entry.kind,
-          reason: built.reason
+          error: failure.message
         });
-        journal?.appendSkip(entry.entrySeq, built.reason);
-        settleHead(pending);
-        return;
-      }
-      pending.state = "pushing";
-      entry.attempts += 1;
-      const pushStartedAtMs = now();
-      let reply;
-      try {
-        reply = await options.push(built.event, built.payload, built.timeoutMs);
-      } catch (error) {
-        pending.state = "queued";
-        const failure = toError(error);
-        if (options.isRetryBudgetExempt?.(failure) === true) {
-          entry.attempts -= 1;
+        if (!stopped && !paused) {
+          scheduleRetry(pending, budgetExemptRetryFallbackDelayMs);
+        }
+      } else {
+        const delayMs = retryDelaysMs[entry.attempts - 1];
+        if (delayMs === void 0) {
+          recordOutcome(pending, { kind: "fail", failure });
+        } else {
           totalRetried += 1;
-          log2("outbox_push_connection_wait", {
+          log2("outbox_push_retry", {
             threadKey,
             entrySeq: entry.entrySeq,
             kind: entry.kind,
+            attempt: entry.attempts,
+            delayMs,
             error: failure.message
           });
-          if (stopped || paused) {
-            return;
-          }
-          await sleep2(budgetExemptRetryFallbackDelayMs);
-          if (stopped || paused) {
-            return;
+          if (!stopped && !paused) {
+            scheduleRetry(pending, delayMs);
           }
-          continue;
-        }
-        const delayMs = retryDelaysMs[entry.attempts - 1];
-        if (delayMs === void 0) {
-          settleFailure(pending, failure);
-          return;
-        }
-        totalRetried += 1;
-        log2("outbox_push_retry", {
-          threadKey,
-          entrySeq: entry.entrySeq,
-          kind: entry.kind,
-          attempt: entry.attempts,
-          delayMs,
-          error: failure.message
-        });
-        await sleep2(delayMs);
-        if (stopped || paused) {
-          return;
         }
-        continue;
       }
-      pending.state = "queued";
-      try {
-        builder.onReply?.(entry.data, reply, context);
-      } catch (error) {
-        log2("outbox_on_reply_failed", {
-          threadKey,
-          entrySeq: entry.entrySeq,
-          kind: entry.kind,
-          error: errorMessage2(error)
-        });
-      }
-      totalAcked += 1;
-      recordPushLatency(Math.max(0, now() - pushStartedAtMs));
-      journal?.appendAck(entry.entrySeq);
-      settleHead(pending);
-      return;
     }
   };
-  const drainLoop = async () => {
-    await Promise.resolve();
-    while (!stopped && !paused) {
-      const pending = headEntry();
-      if (pending === void 0) {
-        return;
+  const pumpWindow = () => {
+    settleContiguousPrefix();
+    if (stopped || paused) {
+      notifyDrainIdle();
+      return;
+    }
+    if (headInBackoff()) {
+      notifyDrainIdle();
+      return;
+    }
+    for (let index = headIndex; index < queue.length && inFlightCount < maxInFlightPushes; index += 1) {
+      const pending = queue[index];
+      if (pending === void 0 || pending.outcome !== void 0 || pending.state === "pushing" || pending.retryTimer !== void 0) {
+        continue;
       }
-      await drainHeadEntry(pending);
+      void pushEntry(pending).then(
+        () => pumpWindow(),
+        (error) => {
+          log2("outbox_drain_loop_error", {
+            threadKey,
+            error: errorMessage2(error)
+          });
+          pumpWindow();
+        }
+      );
     }
+    notifyDrainIdle();
   };
   const ensureDraining = () => {
-    if (drainPromise !== void 0 || paused || stopped) {
+    if (paused || stopped) {
       return;
     }
     if (headEntry() === void 0) {
       return;
     }
-    drainPromise = drainLoop().catch((error) => {
-      log2("outbox_drain_loop_error", {
-        threadKey,
-        error: errorMessage2(error)
-      });
-    }).finally(() => {
-      drainPromise = void 0;
-      ensureDraining();
+    void Promise.resolve().then(() => {
+      if (!stopped && !paused) {
+        pumpWindow();
+      }
     });
   };
   const flush = (timeoutMs) => {
@@ -4881,10 +4983,16 @@ function createThreadOutbox(options) {
       });
     }
     stopped = true;
-    wakeSleep?.();
-    const active = drainPromise;
-    if (active !== void 0) {
-      await Promise.race([active, sleepUncancellable(closeDrainGraceMs)]);
+    for (let index = headIndex; index < queue.length; index += 1) {
+      clearRetryTimer(queue[index]);
+    }
+    if (inFlightCount > 0) {
+      await Promise.race([
+        new Promise((resolve12) => {
+          drainIdleWaiters.push(resolve12);
+        }),
+        sleepUncancellable(closeDrainGraceMs)
+      ]);
     }
     for (const waiter of flushWaiters.splice(0)) {
       if (waiter.timer !== void 0) {
@@ -4903,7 +5011,7 @@ function createThreadOutbox(options) {
       if (input.coalesceKey !== void 0) {
         const key = coalesceMapKey(input.kind, input.coalesceKey);
         const existing = coalescible.get(key);
-        if (existing !== void 0 && existing.state === "queued") {
+        if (existing !== void 0 && existing.state === "queued" && existing.outcome === void 0) {
           existing.entry.data = coalesceEntryData(
             builders[input.kind],
             existing.entry,
@@ -4948,9 +5056,9 @@ function createThreadOutbox(options) {
         const pending = queue[index];
         if (pending !== void 0) {
           pending.entry.attempts = 0;
+          clearRetryTimer(pending);
         }
       }
-      wakeSleep?.();
       ensureDraining();
     },
     metrics: () => {
@@ -6619,6 +6727,7 @@ function createSessionPipeline(host) {
     builders,
     ...host.persistDir === void 0 ? {} : { persistDir: host.persistDir },
     ...host.outboxRetryDelaysMs === void 0 ? {} : { retryDelaysMs: [...host.outboxRetryDelaysMs] },
+    maxInFlightPushes: host.outboxMaxInFlightPushes ?? defaultOutboxMaxInFlightPushes,
     ...host.journalRecoveryMaxAgeMs === void 0 ? {} : { journalRecoveryMaxAgeMs: host.journalRecoveryMaxAgeMs },
     // Budget semantics (pre-merge review finding 6): wait_for_connection
     // failures never consume retry budget - the push never reached the
@@ -7067,7 +7176,7 @@ function sleep(ms) {
     setTimeout(resolve12, ms);
   });
 }
-var defaultSnapshotRetryDelaysMs, toolCallOutputTypes, toolCallItemTypes;
+var defaultSnapshotRetryDelaysMs, defaultOutboxMaxInFlightPushes, toolCallOutputTypes, toolCallItemTypes;
 var init_integration = __esm({
   "src/pipeline/integration.ts"() {
     "use strict";
@@ -7081,6 +7190,7 @@ var init_integration = __esm({
     init_threadEventLoop();
     init_transition();
     defaultSnapshotRetryDelaysMs = [1e3, 5e3];
+    defaultOutboxMaxInFlightPushes = 16;
     toolCallOutputTypes = /* @__PURE__ */ new Map([
       ["function_call", "function_call_output"],
       ["custom_tool_call", "custom_tool_call_output"]
@@ -8739,6 +8849,14 @@ function codexStartRequestTimeoutMs() {
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : CODEX_START_REQUEST_TIMEOUT_MS;
 }
+function outboxMaxInFlightPushesOverride() {
+  const raw = process.env.LINZUMI_OUTBOX_MAX_INFLIGHT_PUSHES?.trim();
+  if (raw === void 0 || raw === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
 function isCodexStartRequestTimeoutError(error) {
   return error instanceof CodexStartRequestTimeoutError;
 }
@@ -8983,7 +9101,7 @@ function createChannelSessionPipeline(args, state, payloadContext) {
     instanceId: args.instanceId,
     threadKey,
     persistDir: args.options.pipelinePersistDir,
-    push: (event, payload) => pipelinePush(args, state, event, payload),
+    push: (event, payload, _timeoutMs, onSent) => pipelinePush(args, state, event, payload, onSent),
     wire: () => ({
       workspaceSlug: session.workspaceSlug,
       channelSlug: session.channelSlug,
@@ -9014,15 +9132,16 @@ function createChannelSessionPipeline(args, state, payloadContext) {
       args.log(event, fields);
     },
     outboxRetryDelaysMs: args.options.pipelineOutboxRetryDelaysMs,
+    outboxMaxInFlightPushes: outboxMaxInFlightPushesOverride(),
     snapshotRetryDelaysMs: args.options.pipelineSnapshotRetryDelaysMs,
     statsIntervalMs: args.options.pipelineStatsIntervalMs,
     turnStalledThresholdMs: args.options.pipelineTurnStalledThresholdMs
   });
 }
-async function pipelinePush(args, state, event, payload) {
+async function pipelinePush(args, state, event, payload, onSent) {
   const prepared = await preparePipelinePushPayload(args, event, payload);
   try {
-    return await pushOk2(args.kandan, args.topic, event, prepared);
+    return await pushOk2(args.kandan, args.topic, event, prepared, onSent);
   } catch (error) {
     if (isConnectionLostPushError(error)) {
       state.pipeline?.pause();
@@ -12060,8 +12179,8 @@ function developerInstructionsForThreadStart(options) {
     })
   };
 }
-async function pushOk2(kandan, topic, event, payload) {
-  const reply = await kandan.push(topic, event, payload);
+async function pushOk2(kandan, topic, event, payload, onSent) {
+  const reply = await kandan.push(topic, event, payload, onSent);
   if (isJsonObject(reply) && reply.status === "ok" && isJsonObject(reply.response)) {
     return reply.response;
   }
@@ -12393,10 +12512,10 @@ function createClaudeCodeSessionPipeline(host) {
   let lastSourceSeq;
   let lastUsage;
   let pipeline2;
-  const push = async (event, payload, timeoutMs) => {
+  const push = async (event, payload, timeoutMs, onSent) => {
     const prepared = host.preparePush === void 0 ? payload : await host.preparePush(event, payload);
     try {
-      return await host.push(event, prepared, timeoutMs);
+      return await host.push(event, prepared, timeoutMs, onSent);
     } catch (error) {
       if (isConnectionLostPushError(error)) {
         pipeline2.pause();
@@ -19829,7 +19948,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.102-beta";
+    linzumiCliVersion = "0.0.103-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -24848,9 +24967,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
             rebuildArgs.codexThreadId
           );
           let rebuilt = false;
-          const rebuildProviderBinding = threadModelProviderBindings.get(
-            rebuildArgs.kandanThreadId
-          ) ?? // Belt-and-suspenders: if the persisted map missed this thread
+          const rebuildProviderBinding = threadModelProviderBindings.get(rebuildArgs.kandanThreadId) ?? // Belt-and-suspenders: if the persisted map missed this thread
           // but the in-scope establishing `control` still carries the
           // provider (the server now re-injects it on reconnect_thread),
           // forward that directly so the rebuild never strands a wafer turn.
@@ -24876,7 +24993,9 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
               // (the in-scope `control` is a reconnect_thread that no longer
               // carries it) so the respawned wafer/GLM worker can load the
               // `linzumi` provider and resume instead of stranding the turn.
-              ...rebuildProviderBinding?.modelProvider === void 0 ? {} : { modelProvider: rebuildProviderBinding.modelProvider },
+              ...rebuildProviderBinding?.modelProvider === void 0 ? {} : {
+                modelProvider: rebuildProviderBinding.modelProvider
+              },
               ...rebuildProviderBinding?.llmProxy === void 0 ? {} : { llmProxy: rebuildProviderBinding.llmProxy },
               sourceSeq: message.seq,
               workDescription: message.body,
@@ -28452,8 +28571,8 @@ async function startClaudeCodeProviderInstance(args) {
       codexThreadId: activeSessionId ?? args.resumeSessionId,
       rootSeq
     }),
-    push: async (event, payload) => {
-      const reply = await args.kandan.push(args.topic, event, payload);
+    push: async (event, payload, _timeoutMs, onSent) => {
+      const reply = await args.kandan.push(args.topic, event, payload, onSent);
       if (isJsonObject(reply) && reply.status === "ok") {
         return reply;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.102-beta",
+  "version": "0.0.103-beta",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {