astrocode-workflow 0.2.0 → 0.3.0

package/src/ui/inject.ts

@@ -1,136 +1,107 @@
 // 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 = {
+
+let isInjecting = false;
+
+const injectionQueue: Array<{
   ctx: any;
-  sessionId: string;
+  sessionId?: string;
   text: string;
   agent?: string;
-};
-
-const injectionQueue: QueueItem[] = [];
-
-let workerRunning = false;
-
-// Used to let callers await "queue drained"
-let drainWaiters: Array<() => void> = [];
+  toast?: { title: string; message: string; variant?: "info" | "success" | "warning" | "error"; durationMs?: number };
+  retry?: { maxAttempts?: number; baseDelayMs?: number };
+}> = [];
 
 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 resolveSessionId(ctx: any, sessionId?: string): string | null {
+  if (sessionId) return sessionId;
+  const direct = (ctx as any)?.sessionID ?? (ctx as any)?.sessionId ?? (ctx as any)?.session?.id;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  return null;
 }
 
-async function sendWithRetries(opts: QueueItem): Promise<void> {
-  const { ctx, sessionId, text } = opts;
-  const agent = opts.agent ?? "Astro";
-  const prefixedText = `[${agent}]\n\n${text}`;
-
-  if (!sessionId) {
-    console.warn("[Astrocode] Injection skipped: missing sessionId");
-    return;
-  }
+async function tryInjectOnce(opts: { ctx: any; sessionId: string; text: string; agent: string }): Promise<void> {
+  const { ctx, sessionId, text, agent } = opts;
 
-  const prompt = getPromptApi(ctx);
-  if (!prompt) {
-    console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
-    return;
+  // Prefer explicit chat prompt API
+  const promptApi = (ctx as any)?.client?.session?.prompt;
+  if (!promptApi) {
+    throw new Error("API not available (ctx.client.session.prompt)");
   }
 
-  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;
-      }
+  const prefixedText = `[${agent}]\n\n${text}`;
 
-      // 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);
-    }
-  }
+  // Some hosts reject unknown fields; keep body minimal and stable.
+  await promptApi({
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text: prefixedText }],
+    },
+  });
 }
 
-async function runWorkerLoop(): Promise<void> {
-  if (workerRunning) return;
-  workerRunning = true;
+async function processQueue() {
+  if (isInjecting) return;
+  if (injectionQueue.length === 0) return;
+
+  isInjecting = true;
 
   try {
-    // Drain sequentially to preserve ordering
     while (injectionQueue.length > 0) {
       const item = injectionQueue.shift();
       if (!item) continue;
-      await sendWithRetries(item);
+
+      const { ctx, text, agent = "Astro" } = item;
+      const sessionId = resolveSessionId(ctx, item.sessionId);
+
+      if (!sessionId) {
+        // Drop on floor: we cannot recover without a session id.
+        // Keep draining the queue so we don't stall.
+        // eslint-disable-next-line no-console
+        console.warn("[Astrocode] Injection skipped: no sessionId");
+        continue;
+      }
+
+      const maxAttempts = item.retry?.maxAttempts ?? 4;
+      const baseDelayMs = item.retry?.baseDelayMs ?? 250;
+
+      let lastErr: any = null;
+
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          await tryInjectOnce({ ctx, sessionId, text, agent });
+          lastErr = null;
+          break;
+        } catch (e) {
+          lastErr = e;
+          const delay = baseDelayMs * Math.pow(2, attempt - 1); // 250, 500, 1000, 2000
+          // eslint-disable-next-line no-console
+          console.warn(`[Astrocode] Injection attempt ${attempt}/${maxAttempts} failed: ${String(e)}; retrying in ${delay}ms`);
+          await sleep(delay);
+        }
+      }
+
+      if (lastErr) {
+        // eslint-disable-next-line no-console
+        console.warn(`[Astrocode] Injection failed permanently after ${maxAttempts} attempts: ${String(lastErr)}`);
+      }
     }
   } finally {
-    workerRunning = false;
-    resolveDrainWaitersIfIdle();
+    isInjecting = false;
   }
 }
 
-/**
- * Enqueue an injection and ensure the worker is running.
- * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
- */
-export function enqueueChatPrompt(opts: QueueItem) {
-  injectionQueue.push(opts);
-  // Kick worker
-  void runWorkerLoop();
-}
-
-/**
- * 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();
+export async function injectChatPrompt(opts: { ctx: any; sessionId?: string; text: string; agent?: string }) {
+  injectionQueue.push({
+    ctx: opts.ctx,
+    sessionId: opts.sessionId,
+    text: opts.text,
+    agent: opts.agent ?? "Astro",
+    retry: { maxAttempts: 4, baseDelayMs: 250 },
   });
-}
 
-/**
- * Deterministic helper: enqueue + flush (recommended for stage boundaries).
- */
-export async function injectChatPrompt(opts: QueueItem): Promise<void> {
-  enqueueChatPrompt(opts);
-  await flushChatPrompts();
+  // Fire-and-forget; queue drain is serialized by isInjecting.
+  void processQueue();
 }