@everydaydevopsio/pilot 0.5.2 → 0.6.1

package/src/browser/interaction/downloads.ts

@@ -0,0 +1,116 @@
+import type { Client } from 'chrome-remote-interface';
+import { tmpdir } from 'os';
+import { resolve } from 'path';
+
+export interface DownloadRecord {
+  guid: string;
+  url: string;
+  suggestedFilename: string;
+  state: 'inProgress' | 'completed' | 'canceled';
+  receivedBytes: number;
+  totalBytes: number;
+  timestamp: number;
+}
+
+export class DownloadTracker {
+  private downloads = new Map<string, DownloadRecord>();
+
+  track(record: DownloadRecord): void {
+    this.downloads.set(record.guid, record);
+  }
+
+  update(guid: string, patch: Partial<DownloadRecord>): void {
+    const existing = this.downloads.get(guid);
+    if (existing) {
+      Object.assign(existing, patch);
+    }
+  }
+
+  get(guid: string): DownloadRecord | undefined {
+    return this.downloads.get(guid);
+  }
+
+  list(): DownloadRecord[] {
+    return [...this.downloads.values()];
+  }
+
+  clear(): number {
+    const count = this.downloads.size;
+    this.downloads.clear();
+    return count;
+  }
+
+  size(): number {
+    return this.downloads.size;
+  }
+}
+
+function getDownloadDir(): string {
+  const env = process.env.PILOT_DOWNLOAD_DIR;
+  if (env) return resolve(env);
+  return resolve(tmpdir(), 'pilot-downloads');
+}
+
+export async function enableDownloads(client: Client): Promise<string> {
+  const downloadPath = getDownloadDir();
+  await client.Browser.setDownloadBehavior({
+    behavior: 'allowAndName',
+    downloadPath,
+    eventsEnabled: true
+  });
+  return downloadPath;
+}
+
+export function attachDownloadHandler(
+  client: Client,
+  tracker: DownloadTracker
+): void {
+  client.Browser.downloadWillBegin((params) => {
+    tracker.track({
+      guid: params.guid,
+      url: params.url,
+      suggestedFilename: params.suggestedFilename,
+      state: 'inProgress',
+      receivedBytes: 0,
+      totalBytes: 0,
+      timestamp: Date.now()
+    });
+  });
+
+  client.Browser.downloadProgress((params) => {
+    const state =
+      params.state === 'completed'
+        ? 'completed'
+        : params.state === 'canceled'
+          ? 'canceled'
+          : 'inProgress';
+    tracker.update(params.guid, {
+      state,
+      receivedBytes: params.receivedBytes ?? 0,
+      totalBytes: params.totalBytes ?? 0
+    });
+  });
+}
+
+export function waitForDownload(
+  tracker: DownloadTracker,
+  guid: string,
+  timeoutMs = 30000
+): Promise<DownloadRecord> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      const record = tracker.get(guid);
+      if (record && record.state !== 'inProgress') {
+        resolve(record);
+        return;
+      }
+      if (Date.now() - start > timeoutMs) {
+        reject(new Error(`Download ${guid} timed out after ${timeoutMs}ms`));
+        return;
+      }
+      setTimeout(check, 200);
+    };
+    check();
+  });
+}

package/src/browser/interaction/events.ts

@@ -0,0 +1,79 @@
+import type { Client } from 'chrome-remote-interface';
+
+/**
+ * Fire framework-compatible input events on an element.
+ * Uses the native value setter to work with React's synthetic event system,
+ * then dispatches native DOM events with bubbling enabled for Vue/Svelte.
+ */
+export async function fireInputEvents(
+  client: Client,
+  objectId: string
+): Promise<void> {
+  await client.Runtime.callFunctionOn({
+    objectId,
+    functionDeclaration: `function() {
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    awaitPromise: false
+  });
+}
+
+/**
+ * Set a form field value using the native setter for React compatibility,
+ * then fire input/change events.
+ */
+export async function setFieldValue(
+  client: Client,
+  objectId: string,
+  value: string
+): Promise<void> {
+  await client.Runtime.callFunctionOn({
+    objectId,
+    functionDeclaration: `function(newValue) {
+      var tag = this.tagName.toLowerCase();
+      if (tag === 'select') {
+        // Select element — set by value
+        for (var i = 0; i < this.options.length; i++) {
+          if (this.options[i].value === newValue) {
+            this.selectedIndex = i;
+            break;
+          }
+        }
+      } else if (this.getAttribute('contenteditable') !== null) {
+        this.textContent = newValue;
+      } else {
+        // Use native setter for React compatibility
+        var proto = tag === 'textarea'
+          ? HTMLTextAreaElement.prototype
+          : HTMLInputElement.prototype;
+        var setter = Object.getOwnPropertyDescriptor(proto, 'value');
+        if (setter && setter.set) {
+          setter.set.call(this, newValue);
+        } else {
+          this.value = newValue;
+        }
+      }
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    arguments: [{ value }],
+    awaitPromise: false
+  });
+}
+
+/**
+ * Get the tag name of an element by its remote object ID.
+ */
+export async function getTagName(
+  client: Client,
+  objectId: string
+): Promise<string> {
+  const { result } = await client.Runtime.callFunctionOn({
+    objectId,
+    functionDeclaration: `function() { return this.tagName ? this.tagName.toLowerCase() : ''; }`,
+    returnByValue: true,
+    awaitPromise: false
+  });
+  return String(result.value ?? '');
+}

package/src/browser/interaction/ref-resolver.ts

@@ -0,0 +1,53 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../inspect/element-ref.js';
+
+export interface ResolvedElement {
+  backendNodeId: number;
+  objectId: string;
+  x: number;
+  y: number;
+}
+
+/**
+ * Resolve an element ref to coordinates and a remote object ID.
+ * Scrolls the element into view first so click coordinates are valid.
+ */
+export async function resolveRef(
+  client: Client,
+  refMap: ElementRefMap,
+  ref: string
+): Promise<ResolvedElement> {
+  const backendNodeId = refMap.resolve(ref);
+
+  // Scroll into view
+  await client.DOM.scrollIntoViewIfNeeded({ backendNodeId });
+
+  // Get center coordinates from box model
+  const { model } = await client.DOM.getBoxModel({ backendNodeId });
+  const content = model.content;
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+
+  // Get remote object for Runtime.callFunctionOn
+  const { object } = await client.DOM.resolveNode({ backendNodeId });
+  if (!object.objectId) {
+    throw new Error(`Could not resolve ref "${ref}" to a remote object`);
+  }
+
+  return {
+    backendNodeId,
+    objectId: object.objectId,
+    x: Math.round(x),
+    y: Math.round(y)
+  };
+}
+
+/**
+ * Focus an element by ref.
+ */
+export async function focusRef(
+  client: Client,
+  backendNodeId: number
+): Promise<void> {
+  await client.DOM.focus({ backendNodeId });
+}

package/src/browser/interaction/uploads.ts

@@ -0,0 +1,60 @@
+import type { Client } from 'chrome-remote-interface';
+import { existsSync, statSync, realpathSync } from 'fs';
+import { resolve, normalize } from 'path';
+
+const DEFAULT_UPLOAD_ROOTS = [process.cwd()];
+
+function getUploadRoots(): string[] {
+  const env = process.env.PILOT_UPLOAD_ROOTS;
+  if (env) {
+    return env
+      .split(',')
+      .map((p) => p.trim())
+      .filter((p) => p.length > 0)
+      .map((p) => resolve(p));
+  }
+  return DEFAULT_UPLOAD_ROOTS;
+}
+
+function isUnderAllowedRoot(filePath: string, roots: string[]): boolean {
+  const resolved = realpathSync(filePath);
+  // Use path separator boundary to prevent "/allowed" matching "/allowed_evil"
+  return roots.some(
+    (root) => resolved === root || resolved.startsWith(root + '/')
+  );
+}
+
+export function validateUploadFiles(files: string[]): void {
+  const roots = getUploadRoots();
+
+  for (const file of files) {
+    const normalized = normalize(resolve(file));
+
+    if (!existsSync(normalized)) {
+      throw new Error(`Upload file not found: ${file}`);
+    }
+
+    const stat = statSync(normalized);
+    if (!stat.isFile()) {
+      throw new Error(`Upload path is not a regular file: ${file}`);
+    }
+
+    if (!isUnderAllowedRoot(normalized, roots)) {
+      throw new Error(
+        `Upload file "${file}" is outside allowed roots. Set PILOT_UPLOAD_ROOTS to configure allowed directories.`
+      );
+    }
+  }
+}
+
+export async function uploadFiles(
+  client: Client,
+  backendNodeId: number,
+  files: string[]
+): Promise<void> {
+  const resolved = files.map((f) => resolve(f));
+  await client.DOM.setFileInputFiles({
+    files: resolved,
+    backendNodeId
+  });
+}

package/src/browser/network/network-buffer.ts

@@ -0,0 +1,133 @@
+import type { NetworkRecord, NetworkSummary, NetworkFilter } from './types.js';
+import { redactHeaders } from './redaction.js';
+
+export class NetworkBuffer {
+  private buffer: NetworkRecord[] = [];
+  private head = 0;
+  private count = 0;
+  private index = new Map<string, number>();
+
+  constructor(private readonly maxSize: number = 1000) {}
+
+  push(record: NetworkRecord): void {
+    if (this.count < this.maxSize) {
+      const idx = this.buffer.length;
+      this.buffer.push(record);
+      this.index.set(record.id, idx);
+      this.count++;
+    } else {
+      // Remove the old record's index entry
+      const oldRecord = this.buffer[this.head];
+      if (oldRecord) {
+        this.index.delete(oldRecord.id);
+      }
+      this.buffer[this.head] = record;
+      this.index.set(record.id, this.head);
+      this.head = (this.head + 1) % this.maxSize;
+    }
+  }
+
+  update(id: string, patch: Partial<NetworkRecord>): void {
+    const idx = this.index.get(id);
+    if (idx === undefined) return;
+    Object.assign(this.buffer[idx], patch);
+  }
+
+  get(id: string): NetworkRecord | undefined {
+    const idx = this.index.get(id);
+    if (idx === undefined) return undefined;
+    return this.buffer[idx];
+  }
+
+  list(filter?: NetworkFilter): NetworkSummary[] {
+    const records = this.toArray();
+    const filtered = this.applyFilter(records, filter);
+    return filtered.map((r) => ({
+      id: r.id,
+      method: r.method,
+      url: r.url,
+      status: r.status,
+      resourceType: r.resourceType,
+      duration: r.duration,
+      mimeType: r.mimeType,
+      size: r.encodedDataLength,
+      failed: r.failed,
+      fromCache: r.fromCache
+    }));
+  }
+
+  getDetail(id: string): NetworkRecord | undefined {
+    const record = this.get(id);
+    if (!record) return undefined;
+    return {
+      ...record,
+      requestHeaders: redactHeaders(record.requestHeaders),
+      responseHeaders: redactHeaders(record.responseHeaders)
+    };
+  }
+
+  clear(): number {
+    const cleared = this.count;
+    this.buffer = [];
+    this.head = 0;
+    this.count = 0;
+    this.index.clear();
+    return cleared;
+  }
+
+  size(): number {
+    return this.count;
+  }
+
+  private toArray(): NetworkRecord[] {
+    if (this.count < this.maxSize) {
+      return [...this.buffer];
+    }
+    return [
+      ...this.buffer.slice(this.head),
+      ...this.buffer.slice(0, this.head)
+    ];
+  }
+
+  private applyFilter(
+    records: NetworkRecord[],
+    filter?: NetworkFilter
+  ): NetworkRecord[] {
+    if (!filter) return records;
+
+    let result = records;
+
+    if (filter.url) {
+      const urlLower = filter.url.toLowerCase();
+      result = result.filter((r) => r.url.toLowerCase().includes(urlLower));
+    }
+
+    if (filter.method) {
+      const methodUpper = filter.method.toUpperCase();
+      result = result.filter((r) => r.method === methodUpper);
+    }
+
+    if (filter.statusMin !== undefined) {
+      result = result.filter((r) => r.status >= filter.statusMin!);
+    }
+
+    if (filter.statusMax !== undefined) {
+      result = result.filter((r) => r.status <= filter.statusMax!);
+    }
+
+    if (filter.resourceType) {
+      const rt = filter.resourceType.toLowerCase();
+      result = result.filter((r) => r.resourceType.toLowerCase() === rt);
+    }
+
+    if (filter.failed !== undefined) {
+      result = result.filter((r) => r.failed === filter.failed);
+    }
+
+    if (filter.limit !== undefined && result.length > filter.limit) {
+      result = result.slice(-filter.limit);
+    }
+
+    return result;
+  }
+}

package/src/browser/network/network-monitor.ts

@@ -0,0 +1,107 @@
+import type { Client } from 'chrome-remote-interface';
+import type { NetworkRecord } from './types.js';
+import type { NetworkBuffer } from './network-buffer.js';
+
+/**
+ * Parse CDP headers object to a flat Record.
+ * CDP returns headers as { "Header-Name": "value" }.
+ */
+function parseHeaders(
+  headers?: Record<string, string>
+): Record<string, string> {
+  if (!headers) return {};
+  return { ...headers };
+}
+
+export function attachNetworkMonitor(
+  client: Client,
+  buffer: NetworkBuffer
+): void {
+  client.Network.requestWillBeSent((params) => {
+    const record: NetworkRecord = {
+      id: params.requestId,
+      method: params.request.method,
+      url: params.request.url,
+      status: 0,
+      resourceType: params.type ?? 'Other',
+      startTime: Date.now(),
+      failed: false,
+      requestHeaders: parseHeaders(
+        params.request.headers as Record<string, string>
+      ),
+      responseHeaders: {},
+      mimeType: '',
+      encodedDataLength: 0,
+      fromCache: false,
+      complete: false
+    };
+    buffer.push(record);
+  });
+
+  client.Network.responseReceived((params) => {
+    buffer.update(params.requestId, {
+      status: params.response.status,
+      responseHeaders: parseHeaders(
+        params.response.headers as Record<string, string>
+      ),
+      mimeType: params.response.mimeType ?? '',
+      fromCache: params.response.fromDiskCache ?? false
+    });
+  });
+
+  client.Network.loadingFinished((params) => {
+    const now = Date.now();
+    const existing = buffer.get(params.requestId);
+    buffer.update(params.requestId, {
+      endTime: now,
+      duration: existing?.startTime ? now - existing.startTime : undefined,
+      encodedDataLength: params.encodedDataLength ?? 0,
+      complete: true
+    });
+  });
+
+  client.Network.loadingFailed((params) => {
+    const now = Date.now();
+    const existing = buffer.get(params.requestId);
+    buffer.update(params.requestId, {
+      endTime: now,
+      duration: existing?.startTime ? now - existing.startTime : undefined,
+      failed: true,
+      errorText: params.errorText,
+      complete: true
+    });
+  });
+}
+
+const MAX_RESPONSE_BODY_SIZE = 1024 * 1024; // 1 MB
+
+export async function getResponseBody(
+  client: Client,
+  requestId: string
+): Promise<{ body: string; truncated: boolean } | null> {
+  try {
+    const { body, base64Encoded } = await client.Network.getResponseBody({
+      requestId
+    });
+
+    if (base64Encoded) {
+      const decoded = Buffer.from(body, 'base64');
+      if (decoded.length > MAX_RESPONSE_BODY_SIZE) {
+        return {
+          body: decoded.subarray(0, MAX_RESPONSE_BODY_SIZE).toString('utf-8'),
+          truncated: true
+        };
+      }
+      return { body: decoded.toString('utf-8'), truncated: false };
+    }
+
+    if (body.length > MAX_RESPONSE_BODY_SIZE) {
+      return { body: body.slice(0, MAX_RESPONSE_BODY_SIZE), truncated: true };
+    }
+
+    return { body, truncated: false };
+  } catch {
+    // Body may not be available (e.g., still loading, or was a redirect)
+    return null;
+  }
+}

package/src/browser/network/redaction.ts

@@ -0,0 +1,42 @@
+const DEFAULT_REDACT_HEADERS = new Set([
+  'authorization',
+  'proxy-authorization',
+  'cookie',
+  'set-cookie',
+  'x-api-key'
+]);
+
+let customRedactHeaders: Set<string> | null = null;
+
+export function getRedactHeaders(): Set<string> {
+  if (customRedactHeaders) return customRedactHeaders;
+
+  const env = process.env.PILOT_REDACT_HEADERS;
+  if (env) {
+    customRedactHeaders = new Set(
+      env.split(',').map((h) => h.trim().toLowerCase())
+    );
+    // Merge with defaults
+    for (const h of DEFAULT_REDACT_HEADERS) {
+      customRedactHeaders.add(h);
+    }
+    return customRedactHeaders;
+  }
+
+  return DEFAULT_REDACT_HEADERS;
+}
+
+export function redactHeaders(
+  headers: Record<string, string>
+): Record<string, string> {
+  const redactSet = getRedactHeaders();
+  const result: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (redactSet.has(key.toLowerCase())) {
+      result[key] = '[REDACTED]';
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}

package/src/browser/network/types.ts

@@ -0,0 +1,47 @@
+export interface NetworkRecord {
+  id: string;
+  method: string;
+  url: string;
+  status: number;
+  resourceType: string;
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  failed: boolean;
+  errorText?: string;
+  requestHeaders: Record<string, string>;
+  responseHeaders: Record<string, string>;
+  mimeType: string;
+  encodedDataLength: number;
+  fromCache: boolean;
+  complete: boolean;
+}
+
+export interface NetworkSummary {
+  id: string;
+  method: string;
+  url: string;
+  status: number;
+  resourceType: string;
+  duration?: number;
+  mimeType: string;
+  size: number;
+  failed: boolean;
+  fromCache: boolean;
+}
+
+export interface NetworkDetail extends NetworkRecord {
+  requestBody?: string;
+  responseBody?: string;
+  bodyTruncated?: boolean;
+}
+
+export interface NetworkFilter {
+  url?: string;
+  method?: string;
+  statusMin?: number;
+  statusMax?: number;
+  resourceType?: string;
+  failed?: boolean;
+  limit?: number;
+}