astrocode-workflow 0.2.0 → 0.2.2

package/src/ui/inject.ts

@@ -1,136 +1,129 @@
 // src/ui/inject.ts
-//
-// Deterministic chat injection:
-// - Always enqueue
-// - Process sequentially (per-process single worker)
-// - Retries with backoff
-// - flush() lets callers wait until injections are actually sent
-//
-// IMPORTANT: Callers who need reliability must `await injectChatPrompt(...)`
-// or `await flushChatPrompts()` after enqueueing.
-
-type QueueItem = {
+type InjectionItem = {
   ctx: any;
   sessionId: string;
   text: string;
   agent?: string;
+  attempts: number;
+  resolve: () => void;
+  reject: (err: any) => void;
 };
 
-const injectionQueue: QueueItem[] = [];
+const MAX_ATTEMPTS = 4;
+const RETRY_DELAYS_MS = [250, 500, 1000, 2000]; // attempt 1..4
 
-let workerRunning = false;
-
-// Used to let callers await "queue drained"
-let drainWaiters: Array<() => void> = [];
+// Per-session queues so one stuck session doesn't block others
+const queues = new Map<string, InjectionItem[]>();
+const running = new Set<string>();
 
 function sleep(ms: number) {
-  return new Promise<void>((resolve) => setTimeout(resolve, ms));
-}
-
-function resolveDrainWaitersIfIdle() {
-  if (workerRunning) return;
-  if (injectionQueue.length !== 0) return;
-
-  const waiters = drainWaiters;
-  drainWaiters = [];
-  for (const w of waiters) w();
+  return new Promise((r) => setTimeout(r, ms));
 }
 
-function getPromptApi(ctx: any) {
-  const fn = ctx?.client?.session?.prompt;
-  return typeof fn === "function" ? fn.bind(ctx.client.session) : null;
+function getPromptInvoker(ctx: any): { session: any; prompt: Function } {
+  const session = ctx?.client?.session;
+  const prompt = session?.prompt;
+  if (!session || typeof prompt !== "function") {
+    throw new Error("API not available (ctx.client.session.prompt)");
+  }
+  return { session, prompt };
 }
 
-async function sendWithRetries(opts: QueueItem): Promise<void> {
-  const { ctx, sessionId, text } = opts;
-  const agent = opts.agent ?? "Astro";
+async function tryInjectOnce(item: InjectionItem): Promise<void> {
+  const { ctx, sessionId, text, agent = "Astro" } = item;
   const prefixedText = `[${agent}]\n\n${text}`;
 
-  if (!sessionId) {
-    console.warn("[Astrocode] Injection skipped: missing sessionId");
-    return;
-  }
+  const { session, prompt } = getPromptInvoker(ctx);
 
-  const prompt = getPromptApi(ctx);
-  if (!prompt) {
-    console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
-    return;
-  }
-
-  const maxAttempts = 3;
-  let attempt = 0;
-
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    try {
-      await prompt({
-        path: { id: sessionId },
-        body: {
-          parts: [{ type: "text", text: prefixedText }],
-          agent,
-        },
-      });
-      return;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      const isLast = attempt >= maxAttempts;
-
-      if (isLast) {
-        console.warn(`[Astrocode] Injection failed (final): ${msg}`);
-        return;
-      }
-
-      // Exponential backoff + jitter
-      const base = 150 * Math.pow(2, attempt - 1); // 150, 300, 600
-      const jitter = Math.floor(Math.random() * 120);
-      await sleep(base + jitter);
-    }
-  }
+  // IMPORTANT: force correct `this` binding
+  await prompt.call(session, {
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text: prefixedText }],
+      agent,
+    },
+  });
 }
 
-async function runWorkerLoop(): Promise<void> {
-  if (workerRunning) return;
-  workerRunning = true;
+async function runSessionQueue(sessionId: string) {
+  if (running.has(sessionId)) return;
+  running.add(sessionId);
 
   try {
-    // Drain sequentially to preserve ordering
-    while (injectionQueue.length > 0) {
-      const item = injectionQueue.shift();
-      if (!item) continue;
-      await sendWithRetries(item);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const q = queues.get(sessionId);
+      if (!q || q.length === 0) break;
+
+      const item = q.shift()!;
+      try {
+        await tryInjectOnce(item);
+        item.resolve();
+      } catch (err) {
+        item.attempts += 1;
+
+        const msg = err instanceof Error ? err.message : String(err);
+        const delay = RETRY_DELAYS_MS[Math.min(item.attempts - 1, RETRY_DELAYS_MS.length - 1)] ?? 2000;
+
+        if (item.attempts >= MAX_ATTEMPTS) {
+          console.warn(
+            `[Astrocode] Injection failed permanently after ${item.attempts} attempts: ${msg}`
+          );
+          item.reject(err);
+          continue;
+        }
+
+        console.warn(
+          `[Astrocode] Injection attempt ${item.attempts}/${MAX_ATTEMPTS} failed: ${msg}; retrying in ${delay}ms`
+        );
+
+        await sleep(delay);
+
+        // Requeue at front to preserve order (and avoid starving later messages)
+        const q2 = queues.get(sessionId) ?? [];
+        q2.unshift(item);
+        queues.set(sessionId, q2);
+      }
     }
   } finally {
-    workerRunning = false;
-    resolveDrainWaitersIfIdle();
+    running.delete(sessionId);
   }
 }
 
 /**
- * Enqueue an injection and ensure the worker is running.
- * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
+ * Inject a visible prompt into the conversation.
+ * - Deterministic ordering per session
+ * - Correct SDK binding (prevents `this._client` undefined)
+ * - Awaitable: resolves when delivered, rejects after max retries
  */
-export function enqueueChatPrompt(opts: QueueItem) {
-  injectionQueue.push(opts);
-  // Kick worker
-  void runWorkerLoop();
-}
+export async function injectChatPrompt(opts: {
+  ctx: any;
+  sessionId?: string;
+  text: string;
+  agent?: string;
+}): Promise<void> {
+  const sessionId = opts.sessionId ?? (opts.ctx as any)?.sessionID;
+  if (!sessionId) {
+    console.warn("[Astrocode] Skipping injection: No sessionId provided");
+    return;
+  }
 
-/**
- * Wait until all queued injections have been processed (sent or exhausted retries).
- */
-export function flushChatPrompts(): Promise<void> {
-  if (!workerRunning && injectionQueue.length === 0) return Promise.resolve();
-  return new Promise<void>((resolve) => {
-    drainWaiters.push(resolve);
-    // Ensure worker is running (in case someone enqueued without kick)
-    void runWorkerLoop();
+  return new Promise<void>((resolve, reject) => {
+    const item: InjectionItem = {
+      ctx: opts.ctx,
+      sessionId,
+      text: opts.text,
+      agent: opts.agent,
+      attempts: 0,
+      resolve,
+      reject,
+    };
+
+    const q = queues.get(sessionId) ?? [];
+    q.push(item);
+    queues.set(sessionId, q);
+
+    // Fire worker (don't await here; caller awaits the returned Promise)
+    void runSessionQueue(sessionId);
   });
 }
-
-/**
- * Deterministic helper: enqueue + flush (recommended for stage boundaries).
- */
-export async function injectChatPrompt(opts: QueueItem): Promise<void> {
-  enqueueChatPrompt(opts);
-  await flushChatPrompts();
-}