@everydaydevopsio/pilot 0.5.2 → 0.6.1

package/src/commands/hover.ts

@@ -0,0 +1,42 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import { resolveRef } from '../browser/interaction/ref-resolver.js';
+
+export interface HoverParams {
+  ref?: string;
+  x?: number;
+  y?: number;
+}
+
+export interface HoverResult {
+  x: number;
+  y: number;
+}
+
+export async function executeHover(
+  client: Client,
+  refMap: ElementRefMap,
+  params: HoverParams
+): Promise<HoverResult> {
+  let x: number;
+  let y: number;
+
+  if (params.ref) {
+    const resolved = await resolveRef(client, refMap, params.ref);
+    x = resolved.x;
+    y = resolved.y;
+  } else if (params.x !== undefined && params.y !== undefined) {
+    x = params.x;
+    y = params.y;
+  } else {
+    throw new Error('Either ref or x/y coordinates are required');
+  }
+
+  await client.Input.dispatchMouseEvent({
+    type: 'mouseMoved',
+    x,
+    y
+  });
+
+  return { x, y };
+}

package/src/commands/navigate.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import type { Client } from 'chrome-remote-interface';
 import type { BrowserManager } from '../browser.js';
+import { checkOrigin } from '../browser/security/origins.js';
 
 export const NavigateParamsSchema = z.object({
   url: z.string().url(),
@@ -22,6 +23,14 @@ export async function executeNavigate(
   manager: BrowserManager,
   params: NavigateParams
 ): Promise<NavigateResult> {
+  // Check origin policy before navigation
+  const originCheck = checkOrigin(params.url);
+  if (!originCheck.allowed) {
+    throw new Error(
+      originCheck.reason ?? 'Navigation blocked by origin policy'
+    );
+  }
+
   let finalStatus = 200;
 
   const navigationPromise = new Promise<{ url: string; status: number }>(
@@ -97,6 +106,17 @@ export async function executeNavigate(
 
   try {
     const result = await navigationPromise;
+
+    // Check final URL after redirects — block if redirected to a blocked origin
+    const finalCheck = checkOrigin(result.url);
+    if (!finalCheck.allowed) {
+      // Navigate away from the blocked origin
+      await client.Page.navigate({ url: 'about:blank' });
+      throw new Error(
+        `Redirect landed on blocked origin: ${finalCheck.reason}`
+      );
+    }
+
     return result;
   } finally {
     // Event listeners are auto-removed when client disconnects;

package/src/commands/network.ts

@@ -0,0 +1,141 @@
+import type { Client } from 'chrome-remote-interface';
+import type { NetworkBuffer } from '../browser/network/network-buffer.js';
+import type {
+  NetworkSummary,
+  NetworkDetail,
+  NetworkFilter
+} from '../browser/network/types.js';
+import { getResponseBody } from '../browser/network/network-monitor.js';
+
+export type NetworkAction = 'list' | 'get' | 'clear';
+
+export interface NetworkParams {
+  action: NetworkAction;
+  requestId?: string;
+  url?: string;
+  method?: string;
+  statusMin?: number;
+  statusMax?: number;
+  resourceType?: string;
+  failed?: boolean;
+  limit?: number;
+}
+
+export interface NetworkListResult {
+  action: 'list';
+  count: number;
+  requests: NetworkSummary[];
+}
+
+export interface NetworkGetResult {
+  action: 'get';
+  request: NetworkDetail;
+}
+
+export interface NetworkClearResult {
+  action: 'clear';
+  cleared: number;
+}
+
+export type NetworkResult =
+  NetworkListResult | NetworkGetResult | NetworkClearResult;
+
+export async function executeNetwork(
+  client: Client,
+  buffer: NetworkBuffer,
+  params: NetworkParams
+): Promise<NetworkResult> {
+  switch (params.action) {
+    case 'list': {
+      const filter: NetworkFilter = {
+        url: params.url,
+        method: params.method,
+        statusMin: params.statusMin,
+        statusMax: params.statusMax,
+        resourceType: params.resourceType,
+        failed: params.failed,
+        limit: params.limit
+      };
+      const requests = buffer.list(filter);
+      return { action: 'list', count: requests.length, requests };
+    }
+
+    case 'get': {
+      if (!params.requestId) {
+        throw new Error('requestId is required for action "get"');
+      }
+      const record = buffer.getDetail(params.requestId);
+      if (!record) {
+        throw new Error(
+          `No network request found with id: ${params.requestId}`
+        );
+      }
+      // Lazily fetch response body
+      const bodyResult = await getResponseBody(client, params.requestId);
+      // record headers are already redacted by getDetail()
+      const detail: NetworkDetail = {
+        ...record,
+        ...(bodyResult && {
+          responseBody: bodyResult.body,
+          bodyTruncated: bodyResult.truncated
+        })
+      };
+      return { action: 'get', request: detail };
+    }
+
+    case 'clear': {
+      const cleared = buffer.clear();
+      return { action: 'clear', cleared };
+    }
+  }
+}
+
+export function formatNetworkList(result: NetworkListResult): string {
+  if (result.requests.length === 0) {
+    return 'No network requests captured.';
+  }
+  const lines = [`Network requests (${result.count}):\n`];
+  for (const req of result.requests) {
+    const status = req.failed ? 'FAILED' : String(req.status);
+    const dur = req.duration !== undefined ? `${req.duration}ms` : '...';
+    const size =
+      req.size > 1024 ? `${(req.size / 1024).toFixed(1)}KB` : `${req.size}B`;
+    lines.push(
+      `  [${req.id}] ${req.method} ${status} ${req.url} (${dur}, ${size})`
+    );
+  }
+  return lines.join('\n');
+}
+
+export function formatNetworkDetail(result: NetworkGetResult): string {
+  const r = result.request;
+  const lines = [
+    `${r.method} ${r.url}`,
+    `Status: ${r.failed ? `FAILED — ${r.errorText}` : r.status}`,
+    `Type: ${r.resourceType} (${r.mimeType})`,
+    `Duration: ${r.duration !== undefined ? `${r.duration}ms` : 'unknown'}`,
+    `Size: ${r.encodedDataLength}B`,
+    `Cache: ${r.fromCache ? 'yes' : 'no'}`
+  ];
+
+  if (Object.keys(r.requestHeaders).length > 0) {
+    lines.push('', 'Request Headers:');
+    for (const [k, v] of Object.entries(r.requestHeaders)) {
+      lines.push(`  ${k}: ${v}`);
+    }
+  }
+
+  if (Object.keys(r.responseHeaders).length > 0) {
+    lines.push('', 'Response Headers:');
+    for (const [k, v] of Object.entries(r.responseHeaders)) {
+      lines.push(`  ${k}: ${v}`);
+    }
+  }
+
+  if (r.responseBody !== undefined) {
+    const truncNote = r.bodyTruncated ? ' (truncated to 1MB)' : '';
+    lines.push('', `Response Body${truncNote}:`, r.responseBody);
+  }
+
+  return lines.join('\n');
+}

package/src/commands/performance.ts

@@ -0,0 +1,51 @@
+import type { Client } from 'chrome-remote-interface';
+import {
+  type TraceState,
+  startTrace,
+  stopTrace
+} from '../browser/performance/trace.js';
+import {
+  analyzePerformance,
+  formatPerformanceSummary
+} from '../browser/performance/analyze.js';
+
+export type PerformanceAction = 'start' | 'stop' | 'analyze';
+
+export interface PerformanceParams {
+  action: PerformanceAction;
+}
+
+export interface PerformanceResult {
+  action: PerformanceAction;
+  text: string;
+}
+
+export async function executePerformance(
+  client: Client,
+  traceState: TraceState,
+  params: PerformanceParams
+): Promise<PerformanceResult> {
+  switch (params.action) {
+    case 'start': {
+      await client.Performance.enable();
+      await startTrace(client, traceState);
+      return { action: 'start', text: 'Performance tracing started.' };
+    }
+
+    case 'stop': {
+      await stopTrace(client, traceState);
+      return {
+        action: 'stop',
+        text: `Tracing stopped. ${traceState.events.length} events captured. Use action="analyze" to view summary.`
+      };
+    }
+
+    case 'analyze': {
+      const summary = await analyzePerformance(client, traceState.events);
+      return {
+        action: 'analyze',
+        text: formatPerformanceSummary(summary)
+      };
+    }
+  }
+}

package/src/commands/press_key.ts

@@ -0,0 +1,134 @@
+import type { Client } from 'chrome-remote-interface';
+
+/**
+ * Map of named keys to CDP key event properties.
+ */
+const KEY_MAP: Record<
+  string,
+  { key: string; code: string; keyCode?: number; text?: string }
+> = {
+  enter: { key: 'Enter', code: 'Enter', keyCode: 13, text: '\r' },
+  tab: { key: 'Tab', code: 'Tab', keyCode: 9 },
+  escape: { key: 'Escape', code: 'Escape', keyCode: 27 },
+  backspace: { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+  delete: { key: 'Delete', code: 'Delete', keyCode: 46 },
+  space: { key: ' ', code: 'Space', keyCode: 32, text: ' ' },
+  arrowup: { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+  arrowdown: { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+  arrowleft: { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+  arrowright: { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+  home: { key: 'Home', code: 'Home', keyCode: 36 },
+  end: { key: 'End', code: 'End', keyCode: 35 },
+  pageup: { key: 'PageUp', code: 'PageUp', keyCode: 33 },
+  pagedown: { key: 'PageDown', code: 'PageDown', keyCode: 34 },
+  f1: { key: 'F1', code: 'F1', keyCode: 112 },
+  f2: { key: 'F2', code: 'F2', keyCode: 113 },
+  f3: { key: 'F3', code: 'F3', keyCode: 114 },
+  f4: { key: 'F4', code: 'F4', keyCode: 115 },
+  f5: { key: 'F5', code: 'F5', keyCode: 116 },
+  f6: { key: 'F6', code: 'F6', keyCode: 117 },
+  f7: { key: 'F7', code: 'F7', keyCode: 118 },
+  f8: { key: 'F8', code: 'F8', keyCode: 119 },
+  f9: { key: 'F9', code: 'F9', keyCode: 120 },
+  f10: { key: 'F10', code: 'F10', keyCode: 121 },
+  f11: { key: 'F11', code: 'F11', keyCode: 122 },
+  f12: { key: 'F12', code: 'F12', keyCode: 123 }
+};
+
+// CDP modifier bit flags
+const MODIFIER_FLAGS: Record<string, number> = {
+  alt: 1,
+  control: 2,
+  ctrl: 2,
+  meta: 4,
+  cmd: 4,
+  command: 4,
+  shift: 8
+};
+
+export interface PressKeyParams {
+  key: string;
+}
+
+export interface PressKeyResult {
+  key: string;
+  modifiers: string[];
+}
+
+/**
+ * Parse a key string like "Control+a", "Meta+Shift+Enter", or "Tab".
+ */
+function parseKeyCombo(input: string): {
+  modifiers: number;
+  modifierNames: string[];
+  keyInfo: { key: string; code: string; keyCode?: number; text?: string };
+} {
+  const parts = input.split('+');
+  let modifiers = 0;
+  const modifierNames: string[] = [];
+
+  // Last part is the actual key, everything before is a modifier
+  const keyPart = parts.pop()!;
+
+  for (const mod of parts) {
+    const flag = MODIFIER_FLAGS[mod.toLowerCase()];
+    if (flag) {
+      modifiers |= flag;
+      modifierNames.push(mod);
+    }
+  }
+
+  // Look up the key in our map
+  const mapped = KEY_MAP[keyPart.toLowerCase()];
+  if (mapped) {
+    return { modifiers, modifierNames, keyInfo: mapped };
+  }
+
+  // Single character key
+  if (keyPart.length === 1) {
+    const charCode = keyPart.charCodeAt(0);
+    return {
+      modifiers,
+      modifierNames,
+      keyInfo: {
+        key: keyPart,
+        code: `Key${keyPart.toUpperCase()}`,
+        keyCode: charCode,
+        text: modifiers === 0 ? keyPart : undefined
+      }
+    };
+  }
+
+  // Unknown named key — pass through
+  return {
+    modifiers,
+    modifierNames,
+    keyInfo: { key: keyPart, code: keyPart }
+  };
+}
+
+export async function executePressKey(
+  client: Client,
+  params: PressKeyParams
+): Promise<PressKeyResult> {
+  const { modifiers, modifierNames, keyInfo } = parseKeyCombo(params.key);
+
+  await client.Input.dispatchKeyEvent({
+    type: 'keyDown',
+    key: keyInfo.key,
+    code: keyInfo.code,
+    windowsVirtualKeyCode: keyInfo.keyCode,
+    modifiers,
+    ...(keyInfo.text && { text: keyInfo.text })
+  });
+
+  await client.Input.dispatchKeyEvent({
+    type: 'keyUp',
+    key: keyInfo.key,
+    code: keyInfo.code,
+    windowsVirtualKeyCode: keyInfo.keyCode,
+    modifiers
+  });
+
+  return { key: keyInfo.key, modifiers: modifierNames };
+}

package/src/commands/scroll.ts

@@ -0,0 +1,79 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+
+export interface ScrollParams {
+  ref?: string;
+  x?: number;
+  y?: number;
+  direction?: 'up' | 'down' | 'left' | 'right';
+  amount?: number;
+}
+
+export interface ScrollResult {
+  scrollX: number;
+  scrollY: number;
+}
+
+/**
+ * Scroll the page or an element.
+ * - If ref is given, scrolls the element into view.
+ * - If direction/amount is given, scrolls the page.
+ * - If x/y is given, scrolls the page to absolute coordinates.
+ */
+export async function executeScroll(
+  client: Client,
+  refMap: ElementRefMap,
+  params: ScrollParams
+): Promise<ScrollResult> {
+  if (params.ref) {
+    // Scroll element into view
+    const backendNodeId = refMap.resolve(params.ref);
+    await client.DOM.scrollIntoViewIfNeeded({ backendNodeId });
+
+    const { result } = await client.Runtime.evaluate({
+      expression: `JSON.stringify({ scrollX: window.scrollX, scrollY: window.scrollY })`,
+      returnByValue: true
+    });
+    const pos = JSON.parse(String(result.value));
+    return { scrollX: pos.scrollX, scrollY: pos.scrollY };
+  }
+
+  if (params.direction) {
+    const amount = params.amount ?? 300;
+    const deltaX =
+      params.direction === 'left'
+        ? -amount
+        : params.direction === 'right'
+          ? amount
+          : 0;
+    const deltaY =
+      params.direction === 'up'
+        ? -amount
+        : params.direction === 'down'
+          ? amount
+          : 0;
+
+    await client.Input.dispatchMouseEvent({
+      type: 'mouseWheel',
+      x: 0,
+      y: 0,
+      deltaX,
+      deltaY
+    });
+
+    // Small delay for scroll to take effect
+    await new Promise((r) => setTimeout(r, 100));
+  } else if (params.x !== undefined || params.y !== undefined) {
+    await client.Runtime.evaluate({
+      expression: `window.scrollTo(${params.x ?? 0}, ${params.y ?? 0})`,
+      awaitPromise: false
+    });
+  }
+
+  const { result } = await client.Runtime.evaluate({
+    expression: `JSON.stringify({ scrollX: window.scrollX, scrollY: window.scrollY })`,
+    returnByValue: true
+  });
+  const pos = JSON.parse(String(result.value));
+  return { scrollX: pos.scrollX, scrollY: pos.scrollY };
+}

package/src/commands/select.ts

@@ -0,0 +1,78 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import { resolveRef, focusRef } from '../browser/interaction/ref-resolver.js';
+
+export interface SelectParams {
+  ref: string;
+  value?: string;
+  label?: string;
+  index?: number;
+}
+
+export interface SelectResult {
+  ref: string;
+  selectedValue: string;
+  selectedLabel: string;
+}
+
+/**
+ * Select an option in a <select> element by value, label, or index.
+ */
+export async function executeSelect(
+  client: Client,
+  refMap: ElementRefMap,
+  params: SelectParams
+): Promise<SelectResult> {
+  const resolved = await resolveRef(client, refMap, params.ref);
+
+  await focusRef(client, resolved.backendNodeId);
+
+  const { result, exceptionDetails } = await client.Runtime.callFunctionOn({
+    objectId: resolved.objectId,
+    functionDeclaration: `function(byValue, byLabel, byIndex) {
+      if (this.tagName.toLowerCase() !== 'select') {
+        throw new Error('Element is not a <select>');
+      }
+      var found = false;
+      for (var i = 0; i < this.options.length; i++) {
+        var opt = this.options[i];
+        if (byValue !== null && opt.value === byValue) {
+          this.selectedIndex = i; found = true; break;
+        }
+        if (byLabel !== null && opt.textContent.trim() === byLabel) {
+          this.selectedIndex = i; found = true; break;
+        }
+        if (byIndex !== null && i === byIndex) {
+          this.selectedIndex = i; found = true; break;
+        }
+      }
+      if (!found) throw new Error('Option not found');
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+      var sel = this.options[this.selectedIndex];
+      return { value: sel.value, label: sel.textContent.trim() };
+    }`,
+    arguments: [
+      { value: params.value ?? null },
+      { value: params.label ?? null },
+      { value: params.index ?? null }
+    ],
+    returnByValue: true,
+    awaitPromise: false
+  });
+
+  if (exceptionDetails) {
+    throw new Error(
+      exceptionDetails.exception?.description ??
+        exceptionDetails.text ??
+        'Failed to select option'
+    );
+  }
+
+  const selected = result.value as { value: string; label: string };
+  return {
+    ref: params.ref,
+    selectedValue: selected.value,
+    selectedLabel: selected.label
+  };
+}

package/src/commands/snapshot.ts

@@ -0,0 +1,18 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import { buildSnapshot, formatSnapshot } from '../browser/inspect/snapshot.js';
+import type { SnapshotResult } from '../browser/inspect/types.js';
+
+export interface SnapshotCommandResult {
+  text: string;
+  snapshot: SnapshotResult;
+}
+
+export async function executeSnapshot(
+  client: Client,
+  refMap: ElementRefMap
+): Promise<SnapshotCommandResult> {
+  const snapshot = await buildSnapshot(client, refMap);
+  const text = formatSnapshot(snapshot);
+  return { text, snapshot };
+}

package/src/commands/styles.ts

@@ -0,0 +1,24 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import { getStyles, formatStyles } from '../browser/inspect/styles.js';
+import type { StylesResult } from '../browser/inspect/styles.js';
+
+export interface StylesParams {
+  ref: string;
+  properties?: string[];
+}
+
+export interface StylesCommandResult {
+  text: string;
+  styles: StylesResult;
+}
+
+export async function executeStyles(
+  client: Client,
+  refMap: ElementRefMap,
+  params: StylesParams
+): Promise<StylesCommandResult> {
+  const styles = await getStyles(client, refMap, params.ref, params.properties);
+  const text = formatStyles(styles);
+  return { text, styles };
+}

package/src/commands/type.ts

@@ -1,8 +1,11 @@
 import { z } from 'zod';
 import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import { resolveRef, focusRef } from '../browser/interaction/ref-resolver.js';
 
 export const TypeParamsSchema = z.object({
   text: z.string(),
+  ref: z.string().optional(),
   selector: z.string().optional(),
   clearFirst: z.boolean().default(false),
   delayMs: z.number().int().min(0).default(0)
@@ -30,9 +33,16 @@ async function focusSelector(client: Client, selector: string): Promise<void> {
 
 export async function executeType(
   client: Client,
-  params: TypeParams
+  params: TypeParams,
+  refMap?: ElementRefMap
 ): Promise<TypeResult> {
-  if (params.selector) {
+  if (params.ref) {
+    if (!refMap) {
+      throw new Error('Element ref map is required when using ref parameter');
+    }
+    const resolved = await resolveRef(client, refMap, params.ref);
+    await focusRef(client, resolved.backendNodeId);
+  } else if (params.selector) {
     await focusSelector(client, params.selector);
   }
 

package/src/commands/upload.ts

@@ -0,0 +1,36 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import {
+  validateUploadFiles,
+  uploadFiles
+} from '../browser/interaction/uploads.js';
+
+export interface UploadParams {
+  ref: string;
+  files: string[];
+}
+
+export interface UploadResult {
+  ref: string;
+  files: string[];
+}
+
+export async function executeUpload(
+  client: Client,
+  refMap: ElementRefMap,
+  params: UploadParams
+): Promise<UploadResult> {
+  if (params.files.length === 0) {
+    throw new Error('At least one file is required');
+  }
+
+  const backendNodeId = refMap.resolve(params.ref);
+
+  // Validate files before uploading
+  validateUploadFiles(params.files);
+
+  // Upload to the file input element
+  await uploadFiles(client, backendNodeId, params.files);
+
+  return { ref: params.ref, files: params.files };
+}