Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
12.9 KB
Raw Blame
import { browserScript, evaluate, type Surface } from "@omnirush/cdp";

type SurfaceExpectation = {
  sessionId?: string;
  pane: "primary" | "secondary";
  required?: string[];
  forbidden?: string[];
};
type SurfaceObservation = {
  frames: number;
  mutations: number;
  shortSamples: number;
  longSamples: number;
  elapsedMs: number;
  loaderSeen: boolean;
  text: string;
  violations: string[];
  expired: boolean;
};

declare global {
  interface Window {
    __chatContinuity?: { state: SurfaceObservation; stop(): void };
    __chatCreation?: {
      workspaceLists: number; creates: number; reblocked: boolean; expired: boolean;
      lastCreateAt: number | null; restore(): void;
    };
  }
}

function deferred() {
  let resolve!: () => void;
  let reject!: (error: Error) => void;
  const promise = new Promise<void>((resolvePromise, rejectPromise) => {
    resolve = resolvePromise;
    reject = rejectPromise;
  });
  return { promise, resolve, reject };
}

/** Faults and observers only; navigation and creation remain trusted user actions. */
export function chatContinuity(app: Surface, workspaceId: string) {
  return {
    async observeSurface(expected: SurfaceExpectation) {
      await evaluate(app.client, browserScript((workspaceId, expected) => {
        if (window.__chatContinuity) throw new Error("A chat continuity observer is already active");
        const state: SurfaceObservation = {
          frames: 0, mutations: 0, shortSamples: 0, longSamples: 0, elapsedMs: 0,
          loaderSeen: false, text: "", violations: [], expired: false,
        };
        let selectedAt: number | undefined;
        let frame = 0;
        const visible = (node: HTMLElement) => node.getClientRects().length > 0
          && getComputedStyle(node).visibility !== "hidden" && getComputedStyle(node).display !== "none";
        const sample = () => {
          const pane = document.querySelector<HTMLElement>('[data-workbench-pane="' + expected.pane + '"]');
          const surface = pane?.querySelector<HTMLElement>('[data-session-surface-id]');
          // Arm before the click and inspect the destination's first DOM commit.
          // The URL can change before React commits navigation; the outgoing
          // surface still belongs to the previous conversation during that time.
          const selected = surface && (!expected.sessionId || surface.dataset.sessionSurfaceId === expected.sessionId)
            && surface.dataset.sessionSurfaceWorkspaceId === workspaceId;
          if (selectedAt === undefined && !selected) return;
          selectedAt ??= performance.now();
          state.elapsedMs = performance.now() - selectedAt;
          if (state.elapsedMs < 1500) state.shortSamples++;
          if (state.elapsedMs > 2200) state.longSamples++;
          state.text = [...(pane?.querySelectorAll<HTMLElement>('[data-message-role]') ?? [])]
            .filter(visible).map(node => node.innerText).join("\n");
          const text = pane?.innerText ?? "";
          const starters = ["Try one of these:", "Try one of your organization's prompts:", "Connect a model provider to get started:"]
            .some(label => text.includes(label));
          const loader = text.includes("Opening session") || text.includes("Switching session");
          state.loaderSeen ||= loader;
          const violations = [
            ...(starters ? ["starters in pending or historical conversation"] : []),
            ...(loader && state.elapsedMs < 1500 ? ["loader appeared before its own delay"] : []),
            ...(expected.forbidden ?? []).filter(text => state.text.includes(text)).map(text => "foreign message: " + text),
            ...(expected.required ?? []).filter(text => !state.text.includes(text)).map(text => "cached message missing: " + text),
          ];
          for (const violation of violations) {
            if (!state.violations.includes(violation)) state.violations.push(violation);
          }
        };
        const paint = () => { state.frames++; sample(); frame = requestAnimationFrame(paint); };
        const observer = new MutationObserver(() => { state.mutations++; sample(); });
        observer.observe(document.documentElement, { subtree: true, childList: true, characterData: true, attributes: true });
        frame = requestAnimationFrame(paint);
        sample();
        const timer = setTimeout(() => { state.expired = true; stop(); }, 60000);
        function stop() { clearTimeout(timer); observer.disconnect(); cancelAnimationFrame(frame); }
        window.__chatContinuity = { state, stop };
      }, [workspaceId, expected]));
      let disposed = false;
      return {
        read: () => evaluate(app.client, () => {
          if (!window.__chatContinuity) throw new Error("Chat observer lost its document");
          return window.__chatContinuity.state;
        }),
        async [Symbol.asyncDispose]() {
          if (disposed) return;
          disposed = true;
          await evaluate(app.client, () => { window.__chatContinuity?.stop(); delete window.__chatContinuity; });
        },
      };
    },

    async surfaceState(pane: "primary" | "secondary") {
      return evaluate(app.client, browserScript((pane) => {
        const root = document.querySelector<HTMLElement>('[data-workbench-pane="' + pane + '"]');
        return {
          sessionId: root?.querySelector<HTMLElement>('[data-session-surface-id]')?.dataset.sessionSurfaceId,
          starters: (root?.innerText ?? "").includes("Try one of these:"),
          messages: root?.querySelectorAll('[data-message-role]').length ?? 0,
        };
      }, [pane]));
    },

    async observeCreation() {
      await evaluate(app.client, () => {
        if (window.__chatCreation) throw new Error("A creation observer is already active");
        const originalFetch = window.fetch;
        let frame = 0;
        const state: NonNullable<Window["__chatCreation"]> = {
          workspaceLists: 0, creates: 0, reblocked: false, expired: false, lastCreateAt: null,
          restore() { window.fetch = originalFetch; observer.disconnect(); cancelAnimationFrame(frame); clearTimeout(timer); },
        };
        const sample = () => {
          if (state.creates > 0 && document.body.innerText.includes("Pulling in the latest messages for this task.")) state.reblocked = true;
        };
        const paint = () => { sample(); frame = requestAnimationFrame(paint); };
        const observer = new MutationObserver(sample);
        observer.observe(document.documentElement, { subtree: true, childList: true, characterData: true, attributes: true });
        frame = requestAnimationFrame(paint);
        const timer = setTimeout(() => { state.expired = true; state.restore(); }, 60000);
        window.fetch = function (...args) {
          const request = args[0];
          const path = new URL(request instanceof Request ? request.url : String(request), location.href).pathname;
          const method = args[1]?.method ?? (request instanceof Request ? request.method : "GET");
          if (method === "GET" && path === "/workspaces") state.workspaceLists++;
          if (method === "POST" && /\/(?:opencode|opencode2\/api)\/session$/.test(path)) {
            state.creates++;
            state.lastCreateAt = performance.now();
          }
          return originalFetch.apply(this, args);
        };
        window.__chatCreation = state;
      });
      let disposed = false;
      return {
        read: () => evaluate(app.client, () => {
          const state = window.__chatCreation;
          if (!state) throw new Error("Creation observer lost its document");
          return { workspaceLists: state.workspaceLists, creates: state.creates, reblocked: state.reblocked, expired: state.expired,
            elapsedMs: state.lastCreateAt === null ? 0 : performance.now() - state.lastCreateAt };
        }),
        async [Symbol.asyncDispose]() {
          if (disposed) return;
          disposed = true;
          await evaluate(app.client, () => { window.__chatCreation?.restore(); delete window.__chatCreation; });
        },
      };
    },

    async holdHistory(sessionId: string, ...otherSessionIds: string[]) {
      const endpoint = app.client.webSocketDebuggerUrl;
      if (!endpoint) throw new Error("History fault requires the desktop CDP endpoint");
      const origin = await evaluate(app.client, () => "http://127.0.0.1:" + localStorage.getItem("omnirush.server.port"));
      const sessionIds = [sessionId, ...otherSessionIds];
      const paths = sessionIds.flatMap(id => ["workspace", "w"].flatMap(mount => ["opencode", "opencode2/api"].map(engine =>
        `/${mount}/${encodeURIComponent(workspaceId)}/${engine}/session/${encodeURIComponent(id)}/message`)));
      const socket = new WebSocket(endpoint);
      const ready = deferred();
      const commands = new Map<number, ReturnType<typeof deferred>>();
      const held = new Map<string, { networkId: string; startedAt: number; snapshot: boolean; sessionId: string }>();
      const ended = new Set<string>();
      let nextId = 1;
      let released = false;
      let disposed = false;
      let failure: Error | undefined;
      const command = async (method: string, params = {}) => {
        const id = nextId++;
        const result = deferred();
        commands.set(id, result);
        const timer = setTimeout(() => result.reject(new Error(`History fault timed out: ${method}`)), 15000);
        try { socket.send(JSON.stringify({ id, method, params })); await result.promise; }
        finally { clearTimeout(timer); commands.delete(id); }
      };
      const fail = () => {
        if (disposed) return;
        failure = new Error("History fault lost its CDP connection");
        ready.reject(failure);
        for (const result of commands.values()) result.reject(failure);
      };
      socket.addEventListener("open", () => ready.resolve());
      socket.addEventListener("error", fail);
      socket.addEventListener("close", fail);
      socket.addEventListener("message", event => {
        const message: unknown = JSON.parse(String(event.data));
        if (!message || typeof message !== "object") return;
        if ("id" in message && typeof message.id === "number") {
          const result = commands.get(message.id);
          if ("error" in message) result?.reject(new Error("History fault CDP command failed"));
          else result?.resolve();
        }
        if (!("method" in message) || !("params" in message) || !message.params || typeof message.params !== "object") return;
        const params = message.params;
        if (!("requestId" in params) || typeof params.requestId !== "string") return;
        if (message.method === "Network.loadingFailed" || message.method === "Network.loadingFinished") ended.add(params.requestId);
        if (message.method !== "Fetch.requestPaused") return;
        const request = "request" in params ? params.request : null;
        if (!released && request && typeof request === "object" && "method" in request && request.method === "GET"
          && "url" in request && typeof request.url === "string" && paths.includes(new URL(request.url).pathname)) {
          if (!("networkId" in params) || typeof params.networkId !== "string") { fail(); return; }
          const path = new URL(request.url).pathname;
          const heldSessionId = sessionIds.find(id => path.endsWith(`/${encodeURIComponent(id)}/message`));
          if (!heldSessionId) { fail(); return; }
          // Distinguish the surface snapshot (140) from background sync reads (20).
          held.set(params.requestId, { networkId: params.networkId, startedAt: performance.now(), sessionId: heldSessionId,
            snapshot: new URL(request.url).searchParams.get("limit") === "140" });
        } else void command("Fetch.continueRequest", { requestId: params.requestId }).catch((error: Error) => { failure = error; });
      });
      const timer = setTimeout(() => ready.reject(new Error("History fault could not connect")), 15000);
      try {
        await ready.promise;
        await command("Network.enable");
        await command("Fetch.enable", { patterns: paths.map(path => ({ urlPattern: origin + path + "*", requestStage: "Request" })) });
      } catch (error) { disposed = true; socket.close(); throw error; }
      finally { clearTimeout(timer); }
      return {
        read(id = sessionId) {
          if (failure) throw failure;
          const snapshots = [...held.values()].filter(item => item.sessionId === id && item.snapshot && !ended.has(item.networkId));
          return { held: held.size, pending: !released && snapshots.length > 0,
            elapsedMs: snapshots.length ? Math.max(...snapshots.map(item => performance.now() - item.startedAt)) : 0 };
        },
        async release() {
          released = true;
          await Promise.all([...held].filter(([, item]) => !ended.has(item.networkId))
            .map(([requestId]) => command("Fetch.continueRequest", { requestId })));
        },
        async [Symbol.asyncDispose]() {
          try { await command("Fetch.disable"); }
          finally { disposed = true; socket.close(); }
        },
      };
    },
  };
}