omnirush 0.8.5 → 0.9.0

package/assets/extensions/omnirush/deliveries.ts

@@ -0,0 +1,145 @@
+// deliveries — brings results of background work back into the conversation.
+//
+// Background sub-agents (agents.ts) and background shell commands
+// (bgshell.ts) finish while the main agent works on, waits for the user, or
+// is about to end a one-shot run. Each registers as a source here; one hub
+// per extension instance delivers what they have:
+//
+//   - the agent is busy: the result is steered into the running turn (the
+//     model sees it before its next step);
+//   - the agent is idle: the result starts a new turn;
+//   - one-shot runs (print/json mode) end when the agent settles, so the hub
+//     holds the run open while a source still has work out, delivers each
+//     result as it comes (a new run nested in this settle, whose own settle
+//     resumes this one), and gives each source one last word (`beforeEnd`)
+//     before the run is allowed to end.
+
+export interface DeliveryItem {
+  customType: string;
+  content: string;
+  details?: unknown;
+}
+
+export interface DeliverySource {
+  /** Work of this session whose result the run should still wait for (running, or finished and unread). */
+  hasPending(session: string): boolean;
+  /** Finished results ready now (each becomes one message); marked delivered. */
+  take(session: string): DeliveryItem[];
+  /** Resolves at the next change (something finished). */
+  changed(): Promise<void>;
+  /** One-shot runs with nothing pending: a last message before the run ends, or null. */
+  beforeEnd?(session: string): DeliveryItem | null;
+}
+
+export class DeliveryHub {
+  private readonly pi: any;
+  private readonly sources: DeliverySource[] = [];
+  /** The session this runtime is on (deliveries go to it). */
+  currentSession = "";
+  cwd = process.cwd();
+  /** An agent run is under way (one-shot runs deliver through the settle loop otherwise). */
+  private busy = false;
+  private oneShot = false;
+  private resumeOuter: (() => void) | null = null;
+
+  constructor(pi: any) {
+    this.pi = pi;
+    pi.on("session_start", (_event: any, ctx: any) => {
+      this.sessionOf(ctx);
+    });
+    pi.on("agent_start", (_event: any, ctx: any) => {
+      this.sessionOf(ctx);
+      this.busy = true;
+    });
+    pi.on("agent_settled", (_event: any, ctx: any) => this.settled(ctx));
+  }
+
+  addSource(source: DeliverySource): void {
+    this.sources.push(source);
+  }
+
+  /** A source has something to deliver (called after its own bookkeeping). */
+  notify(): void {
+    queueMicrotask(() => this.deliver());
+  }
+
+  /** The session of a tool or event context (and what the hub learns from it). */
+  sessionOf(ctx: any): string {
+    const id = String(ctx?.sessionManager?.getSessionId?.() ?? "");
+    if (id) this.currentSession = id;
+    if (ctx?.cwd) this.cwd = String(ctx.cwd);
+    if (ctx?.mode === "print" || ctx?.mode === "json") this.oneShot = true;
+    return id;
+  }
+
+  get isOneShot(): boolean {
+    return this.oneShot;
+  }
+
+  private send(item: DeliveryItem): void {
+    this.pi.sendMessage(
+      { customType: item.customType, content: item.content, display: true, ...(item.details !== undefined ? { details: item.details } : {}) },
+      // Busy: into the running turn at its next step. Idle: a new turn.
+      { triggerTurn: true, deliverAs: "steer" },
+    );
+  }
+
+  private deliver(): void {
+    if (!this.currentSession) return;
+    // One-shot and between runs: the agent_settled loop delivers.
+    if (this.oneShot && !this.busy) return;
+    for (const source of this.sources) {
+      for (const item of source.take(this.currentSession)) this.send(item);
+    }
+  }
+
+  private async settled(ctx: any): Promise<void> {
+    this.busy = false;
+    const session = this.sessionOf(ctx);
+    if (!this.oneShot) {
+      // Anything that finished right as the run ended.
+      this.deliver();
+      return;
+    }
+    const outer = this.resumeOuter;
+    this.resumeOuter = null;
+    const idle = () => typeof ctx?.isIdle !== "function" || ctx.isIdle();
+    try {
+      for (;;) {
+        if (!idle()) {
+          // A run started (a delivery): its settle resumes this one.
+          await new Promise<void>((resolve) => { this.resumeOuter = resolve; });
+          break;
+        }
+        if (!session) break;
+        const items = this.sources.flatMap((source) => source.take(session));
+        if (items.length === 0 && this.sources.some((source) => source.hasPending(session))) {
+          await Promise.race(this.sources.map((source) => source.changed()));
+          continue;
+        }
+        if (items.length === 0) {
+          const last = this.sources.map((source) => source.beforeEnd?.(session) ?? null).find((item) => item !== null);
+          if (!last) break;
+          items.push(last);
+        }
+        this.busy = true;
+        for (const item of items) this.send(item);
+        if (idle()) this.busy = false;
+      }
+    } finally {
+      outer?.();
+    }
+  }
+}
+
+const hubs = new WeakMap<object, DeliveryHub>();
+
+/** The hub of this extension instance (created, with its handlers, on first use). */
+export function deliveryHub(pi: any): DeliveryHub {
+  let hub = hubs.get(pi);
+  if (!hub) {
+    hub = new DeliveryHub(pi);
+    hubs.set(pi, hub);
+  }
+  return hub;
+}

package/assets/extensions/omnirush/guard/UPSTREAM

@@ -0,0 +1,2 @@
+Vendored from omnirush-gui apps/server/src/git-command-policy.ts at 51ee01f (origin/main).
+Keep it byte-identical to upstream; CLI-specific logic lives in ../guard-lib.ts.