@everydaydevopsio/pilot 0.5.2 → 0.6.0

package/src/commands/check.ts

@@ -0,0 +1,59 @@
+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 CheckParams {
+  ref: string;
+  checked?: boolean;
+}
+
+export interface CheckResult {
+  ref: string;
+  checked: boolean;
+}
+
+/**
+ * Toggle a checkbox or radio button by ref.
+ * If `checked` is specified, sets it to that state (no-op if already matching).
+ * If omitted, toggles the current state.
+ */
+export async function executeCheck(
+  client: Client,
+  refMap: ElementRefMap,
+  params: CheckParams
+): Promise<CheckResult> {
+  const resolved = await resolveRef(client, refMap, params.ref);
+
+  const { result, exceptionDetails } = await client.Runtime.callFunctionOn({
+    objectId: resolved.objectId,
+    functionDeclaration: `function(desiredState) {
+      var tag = this.tagName.toLowerCase();
+      var type = (this.type || '').toLowerCase();
+      if (tag !== 'input' || (type !== 'checkbox' && type !== 'radio')) {
+        throw new Error('Element is not a checkbox or radio button');
+      }
+      var current = this.checked;
+      var target = desiredState !== null ? desiredState : !current;
+      if (current !== target) {
+        this.click();
+      }
+      return this.checked;
+    }`,
+    arguments: [{ value: params.checked ?? null }],
+    returnByValue: true,
+    awaitPromise: false
+  });
+
+  if (exceptionDetails) {
+    throw new Error(
+      exceptionDetails.exception?.description ??
+        exceptionDetails.text ??
+        'Failed to toggle checkbox'
+    );
+  }
+
+  return {
+    ref: params.ref,
+    checked: result.value as boolean
+  };
+}

package/src/commands/click.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 } from '../browser/interaction/ref-resolver.js';
 
 export const ClickParamsSchema = z
   .object({
+    ref: z.string().optional(),
     selector: z.string().optional(),
     x: z.number().optional(),
     y: z.number().optional(),
@@ -11,9 +14,12 @@ export const ClickParamsSchema = z
     timeoutMs: z.number().int().positive().default(5000)
   })
   .refine(
-    (v) => v.selector !== undefined || (v.x !== undefined && v.y !== undefined),
+    (v) =>
+      v.ref !== undefined ||
+      v.selector !== undefined ||
+      (v.x !== undefined && v.y !== undefined),
     {
-      message: 'Either selector or x/y coordinates are required'
+      message: 'Either ref, selector, or x/y coordinates are required'
     }
   );
 
@@ -52,12 +58,20 @@ async function waitForSelector(
 
 export async function executeClick(
   client: Client,
-  params: ClickParams
+  params: ClickParams,
+  refMap?: ElementRefMap
 ): Promise<ClickResult> {
   let x: number;
   let y: number;
 
-  if (params.selector !== undefined) {
+  if (params.ref !== undefined) {
+    if (!refMap) {
+      throw new Error('Element ref map is required when using ref parameter');
+    }
+    const resolved = await resolveRef(client, refMap, params.ref);
+    x = resolved.x;
+    y = resolved.y;
+  } else if (params.selector !== undefined) {
     const pos = await waitForSelector(
       client,
       params.selector,

package/src/commands/connect.ts

@@ -0,0 +1,40 @@
+import type { BrowserManager } from '../browser/browser-manager.js';
+import type { TabInfo } from '../browser/types.js';
+
+export interface ConnectParams {
+  host?: string;
+  port?: number;
+}
+
+export interface ConnectResult {
+  host: string;
+  port: number;
+  tabs: TabInfo[];
+}
+
+export async function executeConnect(
+  manager: BrowserManager,
+  params: ConnectParams
+): Promise<ConnectResult> {
+  const host = params.host ?? '127.0.0.1';
+  const port = params.port ?? 9222;
+
+  const { tabs } = await manager.connectExisting({ host, port });
+
+  return { host, port, tabs };
+}
+
+export function formatConnectResult(result: ConnectResult): string {
+  const lines = [
+    `Connected to Chrome at ${result.host}:${result.port}`,
+    '',
+    `Tabs (${result.tabs.length}):`
+  ];
+
+  for (const tab of result.tabs) {
+    const active = tab.active ? ' (active)' : '';
+    lines.push(`  [${tab.targetId}] ${tab.title || tab.url}${active}`);
+  }
+
+  return lines.join('\n');
+}

package/src/commands/dialog.ts

@@ -0,0 +1,79 @@
+import type { Client } from 'chrome-remote-interface';
+import type { DialogQueue } from '../browser/interaction/dialogs.js';
+import { handleDialog } from '../browser/interaction/dialogs.js';
+
+export type DialogAction = 'list' | 'accept' | 'dismiss';
+
+export interface DialogParams {
+  action: DialogAction;
+  promptText?: string;
+}
+
+export interface DialogResult {
+  action: DialogAction;
+  dialogs?: Array<{
+    type: string;
+    message: string;
+    defaultPrompt?: string;
+  }>;
+  handled?: boolean;
+}
+
+export async function executeDialog(
+  client: Client,
+  queue: DialogQueue,
+  params: DialogParams
+): Promise<DialogResult> {
+  switch (params.action) {
+    case 'list': {
+      const pending = queue.list();
+      return {
+        action: 'list',
+        dialogs: pending.map((d) => ({
+          type: d.type,
+          message: d.message,
+          defaultPrompt: d.defaultPrompt
+        }))
+      };
+    }
+
+    case 'accept': {
+      const dialog = queue.shift();
+      if (!dialog) {
+        return { action: 'accept', handled: false };
+      }
+      await handleDialog(client, true, params.promptText);
+      return { action: 'accept', handled: true };
+    }
+
+    case 'dismiss': {
+      const dialog = queue.shift();
+      if (!dialog) {
+        return { action: 'dismiss', handled: false };
+      }
+      await handleDialog(client, false);
+      return { action: 'dismiss', handled: true };
+    }
+  }
+}
+
+export function formatDialogResult(result: DialogResult): string {
+  if (result.action === 'list') {
+    const dialogs = result.dialogs ?? [];
+    if (dialogs.length === 0) {
+      return 'No pending dialogs.';
+    }
+    const lines = [`Pending dialogs (${dialogs.length}):`];
+    for (const d of dialogs) {
+      const prompt =
+        d.defaultPrompt !== undefined ? ` (default: "${d.defaultPrompt}")` : '';
+      lines.push(`  [${d.type}] ${d.message}${prompt}`);
+    }
+    return lines.join('\n');
+  }
+
+  if (result.handled) {
+    return `Dialog ${result.action}ed.`;
+  }
+  return 'No pending dialog to handle.';
+}

package/src/commands/downloads.ts

@@ -0,0 +1,111 @@
+import type { DownloadTracker } from '../browser/interaction/downloads.js';
+import { waitForDownload } from '../browser/interaction/downloads.js';
+
+export type DownloadsAction = 'list' | 'wait' | 'clear';
+
+export interface DownloadsParams {
+  action: DownloadsAction;
+  guid?: string;
+  timeoutMs?: number;
+}
+
+export interface DownloadsResult {
+  action: DownloadsAction;
+  downloads?: Array<{
+    guid: string;
+    url: string;
+    filename: string;
+    state: string;
+    receivedBytes: number;
+    totalBytes: number;
+  }>;
+  download?: {
+    guid: string;
+    url: string;
+    filename: string;
+    state: string;
+    receivedBytes: number;
+    totalBytes: number;
+  };
+  cleared?: number;
+}
+
+export async function executeDownloads(
+  tracker: DownloadTracker,
+  params: DownloadsParams
+): Promise<DownloadsResult> {
+  switch (params.action) {
+    case 'list': {
+      const records = tracker.list();
+      return {
+        action: 'list',
+        downloads: records.map((r) => ({
+          guid: r.guid,
+          url: r.url,
+          filename: r.suggestedFilename,
+          state: r.state,
+          receivedBytes: r.receivedBytes,
+          totalBytes: r.totalBytes
+        }))
+      };
+    }
+
+    case 'wait': {
+      if (!params.guid) {
+        throw new Error('guid is required for action "wait"');
+      }
+      const record = await waitForDownload(
+        tracker,
+        params.guid,
+        params.timeoutMs ?? 30000
+      );
+      return {
+        action: 'wait',
+        download: {
+          guid: record.guid,
+          url: record.url,
+          filename: record.suggestedFilename,
+          state: record.state,
+          receivedBytes: record.receivedBytes,
+          totalBytes: record.totalBytes
+        }
+      };
+    }
+
+    case 'clear': {
+      const cleared = tracker.clear();
+      return { action: 'clear', cleared };
+    }
+  }
+}
+
+export function formatDownloadsResult(result: DownloadsResult): string {
+  if (result.action === 'list') {
+    const downloads = result.downloads ?? [];
+    if (downloads.length === 0) {
+      return 'No downloads tracked.';
+    }
+    const lines = [`Downloads (${downloads.length}):`];
+    for (const d of downloads) {
+      const progress =
+        d.totalBytes > 0
+          ? ` ${Math.round((d.receivedBytes / d.totalBytes) * 100)}%`
+          : '';
+      lines.push(`  [${d.guid}] ${d.filename} (${d.state}${progress})`);
+    }
+    return lines.join('\n');
+  }
+
+  if (result.action === 'wait' && result.download) {
+    const d = result.download;
+    const label =
+      d.state === 'completed' ? 'Download complete' : `Download ${d.state}`;
+    return `${label}: ${d.filename} (${d.receivedBytes} bytes)`;
+  }
+
+  if (result.action === 'clear') {
+    return `Cleared ${result.cleared} download records.`;
+  }
+
+  return 'Done.';
+}

package/src/commands/fill.ts

@@ -0,0 +1,34 @@
+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';
+import { setFieldValue } from '../browser/interaction/events.js';
+
+export interface FillParams {
+  ref: string;
+  value: string;
+}
+
+export interface FillResult {
+  ref: string;
+  value: string;
+}
+
+/**
+ * Fill a form field by ref — clears the existing value and sets a new one.
+ * Fires framework-compatible input/change events.
+ */
+export async function executeFill(
+  client: Client,
+  refMap: ElementRefMap,
+  params: FillParams
+): Promise<FillResult> {
+  const resolved = await resolveRef(client, refMap, params.ref);
+
+  // Focus the element
+  await focusRef(client, resolved.backendNodeId);
+
+  // Set value and fire events
+  await setFieldValue(client, resolved.objectId, params.value);
+
+  return { ref: params.ref, value: params.value };
+}

package/src/commands/find.ts

@@ -0,0 +1,52 @@
+import type { Client } from 'chrome-remote-interface';
+import type { ElementRefMap } from '../browser/inspect/element-ref.js';
+import {
+  buildSnapshot,
+  findElements,
+  formatSnapshot
+} from '../browser/inspect/snapshot.js';
+import type { ElementInfo } from '../browser/inspect/types.js';
+
+export interface FindQuery {
+  role?: string;
+  name?: string;
+  text?: string;
+}
+
+export interface FindCommandResult {
+  text: string;
+  elements: ElementInfo[];
+}
+
+export async function executeFind(
+  client: Client,
+  refMap: ElementRefMap,
+  query: FindQuery
+): Promise<FindCommandResult> {
+  // Always builds a fresh snapshot — no caching across calls
+  const snapshot = await buildSnapshot(client, refMap);
+  const matched = findElements(snapshot, query);
+
+  if (matched.length === 0) {
+    const queryParts = Object.entries(query)
+      .filter(([, v]) => v !== undefined)
+      .map(([k, v]) => `${k}="${v}"`);
+    const queryDesc =
+      queryParts.length > 0 ? queryParts.join(', ') : 'the given query';
+    return {
+      text: `No elements found matching ${queryDesc}.`,
+      elements: []
+    };
+  }
+
+  // Format just the matched elements
+  const result = formatSnapshot({
+    ...snapshot,
+    elements: matched
+  });
+
+  return {
+    text: result,
+    elements: matched
+  };
+}

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)
+      };
+    }
+  }
+}