opengstack 0.13.7 → 0.13.9

package/skills/browse/src/buffers.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared buffers and types — extracted to break circular dependency
+ * between server.ts and browser-manager.ts
+ *
+ * CircularBuffer<T>: O(1) insert ring buffer with fixed capacity.
+ *
+ *   ┌───┬───┬───┬───┬───┬───┐
+ *   │ 3 │ 4 │ 5 │   │ 1 │ 2 │  capacity=6, head=4, size=5
+ *   └───┴───┴───┴───┴─▲─┴───┘
+ *                      │
+ *                    head (oldest entry)
+ *
+ *   push() writes at (head+size) % capacity, O(1)
+ *   toArray() returns entries in insertion order, O(n)
+ *   totalAdded keeps incrementing past capacity (flush cursor)
+ */
+
+// ─── CircularBuffer ─────────────────────────────────────────
+
+export class CircularBuffer<T> {
+  private buffer: (T | undefined)[];
+  private head: number = 0;
+  private _size: number = 0;
+  private _totalAdded: number = 0;
+  readonly capacity: number;
+
+  constructor(capacity: number) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+
+  push(entry: T): void {
+    const index = (this.head + this._size) % this.capacity;
+    this.buffer[index] = entry;
+    if (this._size < this.capacity) {
+      this._size++;
+    } else {
+      // Buffer full — advance head (overwrites oldest)
+      this.head = (this.head + 1) % this.capacity;
+    }
+    this._totalAdded++;
+  }
+
+  /** Return entries in insertion order (oldest first) */
+  toArray(): T[] {
+    const result: T[] = [];
+    for (let i = 0; i < this._size; i++) {
+      result.push(this.buffer[(this.head + i) % this.capacity] as T);
+    }
+    return result;
+  }
+
+  /** Return the last N entries (most recent first → reversed to oldest first) */
+  last(n: number): T[] {
+    const count = Math.min(n, this._size);
+    const result: T[] = [];
+    const start = (this.head + this._size - count) % this.capacity;
+    for (let i = 0; i < count; i++) {
+      result.push(this.buffer[(start + i) % this.capacity] as T);
+    }
+    return result;
+  }
+
+  get length(): number {
+    return this._size;
+  }
+
+  get totalAdded(): number {
+    return this._totalAdded;
+  }
+
+  clear(): void {
+    this.head = 0;
+    this._size = 0;
+    // Don't reset totalAdded — flush cursor depends on it
+  }
+
+  /** Get entry by index (0 = oldest) — used by network response matching */
+  get(index: number): T | undefined {
+    if (index < 0 || index >= this._size) return undefined;
+    return this.buffer[(this.head + index) % this.capacity];
+  }
+
+  /** Set entry by index (0 = oldest) — used by network response matching */
+  set(index: number, entry: T): void {
+    if (index < 0 || index >= this._size) return;
+    this.buffer[(this.head + index) % this.capacity] = entry;
+  }
+}
+
+// ─── Entry Types ────────────────────────────────────────────
+
+export interface LogEntry {
+  timestamp: number;
+  level: string;
+  text: string;
+}
+
+export interface NetworkEntry {
+  timestamp: number;
+  method: string;
+  url: string;
+  status?: number;
+  duration?: number;
+  size?: number;
+}
+
+export interface DialogEntry {
+  timestamp: number;
+  type: string;        // 'alert' | 'confirm' | 'prompt' | 'beforeunload'
+  message: string;
+  defaultValue?: string;
+  action: string;      // 'accepted' | 'dismissed'
+  response?: string;   // text provided for prompt
+}
+
+// ─── Buffer Instances ───────────────────────────────────────
+
+const HIGH_WATER_MARK = 50_000;
+
+export const consoleBuffer = new CircularBuffer<LogEntry>(HIGH_WATER_MARK);
+export const networkBuffer = new CircularBuffer<NetworkEntry>(HIGH_WATER_MARK);
+export const dialogBuffer = new CircularBuffer<DialogEntry>(HIGH_WATER_MARK);
+
+// ─── Convenience add functions ──────────────────────────────
+
+export function addConsoleEntry(entry: LogEntry) {
+  consoleBuffer.push(entry);
+}
+
+export function addNetworkEntry(entry: NetworkEntry) {
+  networkBuffer.push(entry);
+}
+
+export function addDialogEntry(entry: DialogEntry) {
+  dialogBuffer.push(entry);
+}

package/skills/browse/src/bun-polyfill.cjs

@@ -0,0 +1,109 @@
+/**
+ * Bun API polyfill for Node.js — Windows compatibility layer.
+ *
+ * On Windows, Bun can't launch or connect to Playwright's Chromium
+ * (oven-sh/bun#4253, #9911). The browse server falls back to running
+ * under Node.js with this polyfill providing Bun API equivalents.
+ *
+ * Loaded via --require before the transpiled server bundle.
+ */
+
+'use strict';
+
+const http = require('http');
+const { spawnSync, spawn } = require('child_process');
+
+globalThis.Bun = {
+  serve(options) {
+    const { port, hostname = '127.0.0.1', fetch } = options;
+
+    const server = http.createServer(async (nodeReq, nodeRes) => {
+      try {
+        const url = `http://${hostname}:${port}${nodeReq.url}`;
+        const headers = new Headers();
+        for (const [key, val] of Object.entries(nodeReq.headers)) {
+          if (val) headers.set(key, Array.isArray(val) ? val[0] : val);
+        }
+
+        let body = null;
+        if (nodeReq.method !== 'GET' && nodeReq.method !== 'HEAD') {
+          body = await new Promise((resolve) => {
+            const chunks = [];
+            nodeReq.on('data', (chunk) => chunks.push(chunk));
+            nodeReq.on('end', () => resolve(Buffer.concat(chunks)));
+          });
+        }
+
+        const webReq = new Request(url, {
+          method: nodeReq.method,
+          headers,
+          body,
+        });
+
+        const webRes = await fetch(webReq);
+
+        nodeRes.statusCode = webRes.status;
+        webRes.headers.forEach((val, key) => {
+          nodeRes.setHeader(key, val);
+        });
+
+        const resBody = await webRes.arrayBuffer();
+        nodeRes.end(Buffer.from(resBody));
+      } catch (err) {
+        nodeRes.statusCode = 500;
+        nodeRes.end(JSON.stringify({ error: err.message }));
+      }
+    });
+
+    server.listen(port, hostname);
+
+    return {
+      stop() { server.close(); },
+      port,
+      hostname,
+    };
+  },
+
+  spawnSync(cmd, options = {}) {
+    const [command, ...args] = cmd;
+    const result = spawnSync(command, args, {
+      stdio: [
+        options.stdin || 'pipe',
+        options.stdout === 'pipe' ? 'pipe' : 'ignore',
+        options.stderr === 'pipe' ? 'pipe' : 'ignore',
+      ],
+      timeout: options.timeout,
+      env: options.env,
+      cwd: options.cwd,
+    });
+
+    return {
+      exitCode: result.status,
+      stdout: result.stdout || Buffer.from(''),
+      stderr: result.stderr || Buffer.from(''),
+    };
+  },
+
+  spawn(cmd, options = {}) {
+    const [command, ...args] = cmd;
+    const stdio = options.stdio || ['pipe', 'pipe', 'pipe'];
+    const proc = spawn(command, args, {
+      stdio,
+      env: options.env,
+      cwd: options.cwd,
+    });
+
+    return {
+      pid: proc.pid,
+      stdout: proc.stdout,
+      stderr: proc.stderr,
+      stdin: proc.stdin,
+      unref() { proc.unref(); },
+      kill(signal) { proc.kill(signal); },
+    };
+  },
+
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  },
+};