opencode-pair-autonomy 1.0.0

package/vendor/mcp/web-agent-mcp/src/core/task-history.ts

@@ -0,0 +1,97 @@
+import path from "node:path";
+import type { WebAgentEnv } from "../config/env.js";
+import { createId } from "../utils/ids.js";
+import { nowIso } from "../utils/time.js";
+import { appendJsonLine } from "../utils/fs.js";
+
+export type TaskRecord = {
+  task_id: string;
+  kind: string;
+  status: "started" | "succeeded" | "failed";
+  created_at: string;
+  ended_at?: string;
+  session_id?: string;
+  page_id?: string;
+  summary?: Record<string, unknown>;
+};
+
+export type ActionRecord = {
+  action_id: string;
+  task_id?: string;
+  session_id?: string;
+  page_id?: string;
+  kind: string;
+  status: "started" | "succeeded" | "failed";
+  started_at: string;
+  ended_at?: string;
+  input_summary?: Record<string, unknown>;
+  result_summary?: Record<string, unknown>;
+  error_code?: string;
+};
+
+export class TaskHistoryStore {
+  private readonly taskPath: string;
+  private readonly actionPath: string;
+
+  constructor(env: WebAgentEnv) {
+    this.taskPath = path.join(env.historyDir, "tasks.jsonl");
+    this.actionPath = path.join(env.historyDir, "actions.jsonl");
+  }
+
+  async startTask(kind: string, summary?: Record<string, unknown>) {
+    const task: TaskRecord = {
+      task_id: createId("task"),
+      kind,
+      status: "started",
+      created_at: nowIso(),
+      summary,
+    };
+    await appendJsonLine(this.taskPath, task);
+    return task;
+  }
+
+  async finishTask(
+    task: TaskRecord,
+    status: "succeeded" | "failed",
+    summary?: Record<string, unknown>,
+  ) {
+    await appendJsonLine(this.taskPath, {
+      ...task,
+      status,
+      ended_at: nowIso(),
+      summary: summary ?? task.summary,
+    });
+  }
+
+  async startAction(
+    kind: string,
+    inputSummary?: Record<string, unknown>,
+    refs?: Partial<ActionRecord>,
+  ) {
+    const action: ActionRecord = {
+      action_id: createId("action"),
+      kind,
+      status: "started",
+      started_at: nowIso(),
+      input_summary: inputSummary,
+      ...refs,
+    };
+    await appendJsonLine(this.actionPath, action);
+    return action;
+  }
+
+  async finishAction(
+    action: ActionRecord,
+    status: "succeeded" | "failed",
+    resultSummary?: Record<string, unknown>,
+    errorCode?: string,
+  ) {
+    await appendJsonLine(this.actionPath, {
+      ...action,
+      status,
+      ended_at: nowIso(),
+      result_summary: resultSummary,
+      error_code: errorCode,
+    });
+  }
+}

package/vendor/mcp/web-agent-mcp/src/index.ts

@@ -0,0 +1,3 @@
+export { createServer, startStdioServer } from "./server.js";
+export type { WebAgentEnv } from "./config/env.js";
+export type { ManagedSession, ManagedPage } from "./core/session-manager.js";

package/vendor/mcp/web-agent-mcp/src/schemas/act.ts

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import {
+  followUpByGoalSchema,
+  observationRecommendationSchema,
+  sessionRestartRecommendationSchema,
+} from "./policy.js";
+
+export const actionResultSchema = z.object({
+  action_id: z.string(),
+  applied_mode: z.enum(["semantic", "physical"]),
+  verification_hint: z.string().optional(),
+  retry_hint: z.string().optional(),
+  fallback_observation: observationRecommendationSchema.optional(),
+  follow_up_by_goal: followUpByGoalSchema,
+  session_restart: sessionRestartRecommendationSchema.optional(),
+});
+
+export const clickInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  selector: z.string().min(1),
+  frame_selector: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "CSS selector of an iframe to scope the action into (e.g. 'iframe#aid-auth-widget-iFrame'). Use when the target element is inside a cross-origin or embedded iframe.",
+    ),
+  button: z.enum(["left", "right", "middle"]).default("left"),
+  click_count: z.number().int().min(1).max(3).default(1),
+  timeout_ms: z.number().int().positive().max(60000).optional(),
+});
+
+export const fillInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  selector: z.string().min(1),
+  frame_selector: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "CSS selector of an iframe to scope the action into (e.g. 'iframe#aid-auth-widget-iFrame'). Use when the target element is inside a cross-origin or embedded iframe.",
+    ),
+  value: z.string(),
+  clear_first: z.boolean().default(true),
+  timeout_ms: z.number().int().positive().max(60000).optional(),
+});
+
+export const pressInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  key: z.string().min(1),
+  selector: z.string().min(1).optional(),
+  frame_selector: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "CSS selector of an iframe to scope the action into. Use when the target element is inside a cross-origin or embedded iframe.",
+    ),
+  timeout_ms: z.number().int().positive().max(60000).optional(),
+});
+
+export const enterCodeInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  selector: z.string().min(1).optional(),
+  frame_selector: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "CSS selector of an iframe to scope the action into. Use when the target element is inside a cross-origin or embedded iframe.",
+    ),
+  code: z.string().min(1),
+  submit: z.boolean().default(false),
+  timeout_ms: z.number().int().positive().max(60000).optional(),
+});
+
+export const waitForInputSchema = z
+  .object({
+    session_id: z.string().min(1),
+    page_id: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+    text: z.string().min(1).optional(),
+    timeout_ms: z.number().int().positive().max(60000).default(5000),
+  })
+  .refine((value) => Boolean(value.selector || value.text), {
+    message: "Provide either selector or text for wait_for.",
+  });
+
+export const wheelInputSchema = z
+  .object({
+    session_id: z.string().min(1),
+    page_id: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+    delta_x: z.number().default(0),
+    delta_y: z.number().default(0),
+    steps: z.number().int().min(1).max(100).default(1),
+    step_delay_ms: z.number().int().min(0).max(1000).default(0),
+    timeout_ms: z.number().int().positive().max(60000).optional(),
+  })
+  .refine((value) => value.delta_x !== 0 || value.delta_y !== 0, {
+    message: "delta_x or delta_y must be non-zero for wheel.",
+  });
+
+export const dragInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  from_selector: z.string().min(1),
+  to_selector: z.string().min(1),
+  steps: z.number().int().min(1).max(200).default(20),
+  timeout_ms: z.number().int().positive().max(60000).optional(),
+});
+
+export const swipeInputSchema = z
+  .object({
+    session_id: z.string().min(1),
+    page_id: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+    start_x: z.number().optional(),
+    start_y: z.number().optional(),
+    delta_x: z.number().default(0),
+    delta_y: z.number().default(0),
+    speed: z.number().positive().max(5000).default(800),
+  })
+  .refine((value) => value.delta_x !== 0 || value.delta_y !== 0, {
+    message: "delta_x or delta_y must be non-zero for swipe.",
+  })
+  .refine(
+    (value) =>
+      Boolean(value.selector) ||
+      (value.start_x !== undefined && value.start_y !== undefined),
+    {
+      message: "Provide a selector or both start_x and start_y for swipe.",
+    },
+  );
+
+export const pinchInputSchema = z
+  .object({
+    session_id: z.string().min(1),
+    page_id: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+    center_x: z.number().optional(),
+    center_y: z.number().optional(),
+    scale_factor: z.number().positive(),
+    speed: z.number().positive().max(5000).default(800),
+  })
+  .refine(
+    (value) =>
+      Boolean(value.selector) ||
+      (value.center_x !== undefined && value.center_y !== undefined),
+    {
+      message: "Provide a selector or both center_x and center_y for pinch.",
+    },
+  );
+
+export type ClickInput = z.infer<typeof clickInputSchema>;
+export type FillInput = z.infer<typeof fillInputSchema>;
+export type PressInput = z.infer<typeof pressInputSchema>;
+export type EnterCodeInput = z.infer<typeof enterCodeInputSchema>;
+export type WaitForInput = z.infer<typeof waitForInputSchema>;
+export type WheelInput = z.infer<typeof wheelInputSchema>;
+export type DragInput = z.infer<typeof dragInputSchema>;
+export type SwipeInput = z.infer<typeof swipeInputSchema>;
+export type PinchInput = z.infer<typeof pinchInputSchema>;

package/vendor/mcp/web-agent-mcp/src/schemas/common.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+
+export const errorTypeSchema = z.enum([
+  "INPUT",
+  "STATE",
+  "BROWSER",
+  "NETWORK",
+  "STORAGE",
+  "INTERNAL",
+]);
+
+export const toolEnvelopeBaseSchema = z.object({
+  ok: z.boolean(),
+  code: z.string(),
+  message: z.string().optional(),
+  task_id: z.string().optional(),
+  action_id: z.string().optional(),
+  session_id: z.string().optional(),
+  page_id: z.string().optional(),
+  artifact_ids: z.array(z.string()).optional(),
+  warnings: z.array(z.string()).optional(),
+  error: z
+    .object({
+      type: errorTypeSchema,
+      details: z.record(z.string(), z.unknown()).optional(),
+    })
+    .optional(),
+});
+
+export type ErrorType = z.infer<typeof errorTypeSchema>;
+
+export type ToolEnvelope<TData = unknown> = z.infer<
+  typeof toolEnvelopeBaseSchema
+> & {
+  data?: TData;
+};
+
+export function createToolTextContent(value: unknown) {
+  return [{ type: "text" as const, text: JSON.stringify(value, null, 2) }];
+}
+
+export function createToolSuccess<TData>(envelope: ToolEnvelope<TData>) {
+  const structuredContent = envelope.data ?? envelope;
+
+  return {
+    content: createToolTextContent(structuredContent),
+    structuredContent,
+  };
+}
+
+export function createToolFailure<TData>(envelope: ToolEnvelope<TData>) {
+  return {
+    content: createToolTextContent(envelope.error ?? envelope),
+    isError: true,
+  };
+}

package/vendor/mcp/web-agent-mcp/src/schemas/observe.ts

@@ -0,0 +1,214 @@
+import { z } from "zod";
+
+export const observeSessionInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional()
+});
+
+export const screenshotInputSchema = observeSessionInputSchema.extend({
+  mode: z.enum(["viewport", "full", "element"]).default("viewport"),
+  selector: z.string().min(1).optional(),
+  format: z.enum(["png", "jpeg"]).default("jpeg"),
+  quality: z.number().int().min(1).max(100).optional()
+}).superRefine((value, ctx) => {
+  if (value.mode === "element" && !value.selector) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "selector is required when screenshot mode is element",
+      path: ["selector"]
+    });
+  }
+});
+
+export const boxesInputSchema = observeSessionInputSchema.extend({
+  selectors: z.array(z.string().min(1)).min(1).max(50)
+});
+
+export const logsInputSchema = observeSessionInputSchema.extend({
+  limit: z.number().int().positive().max(500).default(50)
+});
+
+export const pageStateInputSchema = observeSessionInputSchema.extend({
+  recent_network_limit: z.number().int().positive().max(100).default(10)
+});
+
+export const authStateInputSchema = observeSessionInputSchema.extend({
+  recent_network_limit: z.number().int().positive().max(100).default(20)
+});
+
+export const waitForNetworkInputSchema = observeSessionInputSchema.extend({
+  url_pattern: z.string().min(1),
+  use_regex: z.boolean().default(false),
+  status: z.number().int().min(100).max(599).optional(),
+  outcome: z.enum(["response", "failed"]).optional(),
+  timeout_ms: z.number().int().positive().max(60000).default(5000),
+  poll_interval_ms: z.number().int().positive().max(1000).default(100)
+});
+
+export const artifactMetadataSchema = z.object({
+  artifact_id: z.string(),
+  kind: z.enum(["a11y", "dom", "text", "markdown", "boxes", "screenshot", "console", "network", "eval"]),
+  created_at: z.string(),
+  url: z.string().optional(),
+  title: z.string().optional(),
+  storage_path: z.string().optional(),
+  bytes: z.number().optional()
+});
+
+export const followUpByGoalSchemaLazy = z.object({
+  interact: z.any(),
+  read: z.any(),
+  visual_verify: z.any(),
+  debug: z.any(),
+  gesture: z.any()
+});
+
+const networkEntrySchema = z.object({
+  url: z.string(),
+  method: z.string(),
+  status: z.number().optional(),
+  resourceType: z.string(),
+  outcome: z.enum(["response", "failed"]),
+  failureText: z.string().optional(),
+  timestamp: z.string()
+});
+
+const interactiveElementSchema = z.object({
+  tag: z.string(),
+  type: z.string().optional(),
+  id: z.string().optional(),
+  name: z.string().optional(),
+  placeholder: z.string().optional(),
+  text: z.string().optional(),
+  autocomplete: z.string().optional(),
+  visible: z.boolean()
+});
+
+const frameSummarySchema = z.object({
+  index: z.number().int().nonnegative(),
+  name: z.string().optional(),
+  url: z.string(),
+  title: z.string().optional(),
+  text_preview: z.string(),
+  truncated: z.boolean(),
+  input_count: z.number().int().nonnegative(),
+  button_count: z.number().int().nonnegative()
+});
+
+export const observeA11yOutputSchema = z.object({
+  snapshot_id: z.string(),
+  format: z.literal("a11y"),
+  url: z.string(),
+  title: z.string().optional(),
+  tree: z.unknown(),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const observeDomOutputSchema = z.object({
+  snapshot_id: z.string(),
+  format: z.literal("dom"),
+  url: z.string(),
+  title: z.string().optional(),
+  dom_summary: z.object({
+    headings: z.array(z.string()),
+    links: z.number(),
+    buttons: z.number(),
+    forms: z.number(),
+    inputs: z.number()
+  }),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const observeTextOutputSchema = z.object({
+  artifact_id: z.string(),
+  format: z.enum(["text", "markdown"]),
+  content: z.string(),
+  truncated: z.boolean(),
+  url: z.string(),
+  title: z.string().optional(),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const observeBoxesOutputSchema = z.object({
+  element_map_id: z.string(),
+  elements: z.array(
+    z.object({
+      selector: z.string(),
+      x: z.number(),
+      y: z.number(),
+      width: z.number(),
+      height: z.number(),
+      visible: z.boolean()
+    })
+  )
+});
+
+export const observeLogsOutputSchema = z.object({
+  artifact_id: z.string(),
+  entries: z.array(z.unknown())
+});
+
+export const observeScreenshotOutputSchema = z.object({
+  screenshot_id: z.string(),
+  mode: z.enum(["viewport", "full", "element"]),
+  width: z.number().optional(),
+  height: z.number().optional(),
+  bytes: z.number().optional(),
+  mime_type: z.string(),
+  storage_path: z.string().optional(),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const observePageStateOutputSchema = z.object({
+  snapshot_id: z.string(),
+  url: z.string(),
+  title: z.string().optional(),
+  text: z.string(),
+  truncated: z.boolean(),
+  dom_summary: z.object({
+    headings: z.array(z.string()),
+    links: z.number(),
+    buttons: z.number(),
+    forms: z.number(),
+    inputs: z.number()
+  }),
+  inputs: z.array(interactiveElementSchema),
+  buttons: z.array(interactiveElementSchema),
+  frames: z.array(frameSummarySchema),
+  recent_network: z.array(networkEntrySchema),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const observeAuthStateOutputSchema = z.object({
+  snapshot_id: z.string(),
+  url: z.string(),
+  title: z.string().optional(),
+  state: z.enum([
+    "email_prompt",
+    "password_prompt",
+    "phone_selection",
+    "verification_code",
+    "trust_prompt",
+    "authenticated",
+    "unknown"
+  ]),
+  confidence: z.enum(["high", "medium", "low"]),
+  summary: z.string(),
+  evidence: z.array(z.string()),
+  suggested_selectors: z.array(z.string()),
+  candidate_frames: z.array(frameSummarySchema),
+  recent_network: z.array(networkEntrySchema),
+  follow_up_by_goal: followUpByGoalSchemaLazy
+});
+
+export const waitForNetworkOutputSchema = z.object({
+  entry: networkEntrySchema,
+  elapsed_ms: z.number().int().nonnegative()
+});
+
+export type ScreenshotInput = z.infer<typeof screenshotInputSchema>;
+export type BoxesInput = z.infer<typeof boxesInputSchema>;
+export type LogsInput = z.infer<typeof logsInputSchema>;
+export type PageStateInput = z.infer<typeof pageStateInputSchema>;
+export type AuthStateInput = z.infer<typeof authStateInputSchema>;
+export type WaitForNetworkInput = z.infer<typeof waitForNetworkInputSchema>;

package/vendor/mcp/web-agent-mcp/src/schemas/page.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { followUpByGoalSchema } from "./policy.js";
+
+export const navigatePageInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  url: z.string().url(),
+  wait_until: z.enum(["domcontentloaded", "load", "networkidle"]).default("domcontentloaded")
+});
+
+export const navigatePageOutputSchema = z.object({
+  page_id: z.string(),
+  requested_url: z.string(),
+  final_url: z.string(),
+  title: z.string().optional(),
+  navigation_id: z.string(),
+  timings: z.object({
+    elapsed_ms: z.number().nonnegative()
+  }),
+  follow_up_by_goal: followUpByGoalSchema
+});

package/vendor/mcp/web-agent-mcp/src/schemas/policy.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+export const observationRecommendationSchema = z.object({
+  recommended_tool: z.enum([
+    "observe.a11y",
+    "observe.dom",
+    "observe.text",
+    "observe.boxes",
+    "observe.screenshot"
+  ]),
+  screenshot_mode: z.enum(["none", "element", "viewport", "full"]).default("none"),
+  rationale: z.array(z.string()),
+  escalation_order: z.array(z.string())
+});
+
+export const followUpByGoalSchema = z.object({
+  interact: observationRecommendationSchema,
+  read: observationRecommendationSchema,
+  visual_verify: observationRecommendationSchema,
+  debug: observationRecommendationSchema,
+  gesture: observationRecommendationSchema
+});
+
+export const sessionRestartRecommendationSchema = z.object({
+  recommended: z.boolean(),
+  reason: z.string().optional()
+});
+
+export const recommendObservationInputSchema = z.object({
+  goal: z.enum(["interact", "read", "visual_verify", "debug", "gesture"]),
+  page_state_known: z.boolean().default(false),
+  target_selector_known: z.boolean().default(false),
+  needs_precise_coordinates: z.boolean().default(false),
+  needs_full_page_context: z.boolean().default(false),
+  recent_failure: z
+    .enum(["none", "semantic_not_found", "semantic_failed", "layout_uncertain", "runtime_error"])
+    .default("none")
+});
+
+export const recommendObservationOutputSchema = observationRecommendationSchema;
+
+export type RecommendObservationInput = z.infer<typeof recommendObservationInputSchema>;

package/vendor/mcp/web-agent-mcp/src/schemas/runtime.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const evaluateJsInputSchema = z.object({
+  session_id: z.string().min(1),
+  page_id: z.string().min(1).optional(),
+  expression: z.string().min(1),
+  await_promise: z.boolean().default(true)
+});
+
+export const evaluateJsOutputSchema = z.object({
+  artifact_id: z.string(),
+  value: z.unknown().optional(),
+  preview: z.string().optional(),
+  truncated: z.boolean(),
+  url: z.string(),
+  title: z.string().optional(),
+  bytes: z.number().optional(),
+  storage_path: z.string().optional()
+});
+
+export type EvaluateJsInput = z.infer<typeof evaluateJsInputSchema>;

package/vendor/mcp/web-agent-mcp/src/schemas/session.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+
+export const profileModeSchema = z.enum(["ephemeral", "persistent"]);
+
+export const viewportSchema = z.object({
+  width: z.number().int().positive(),
+  height: z.number().int().positive()
+});
+
+export const createSessionInputSchema = z.object({
+  profile_mode: profileModeSchema.optional(),
+  locale: z.string().optional(),
+  timezone_id: z.string().optional(),
+  user_data_dir: z.string().optional(),
+  profile_directory: z.string().optional(),
+  humanize: z.boolean().optional(),
+  launch_args: z.array(z.string().min(1)).max(20).optional(),
+  viewport: viewportSchema.optional()
+});
+
+export const closeSessionInputSchema = z.object({
+  session_id: z.string().min(1)
+});
+
+export const restartSessionInputSchema = z.object({
+  session_id: z.string().min(1)
+});
+
+export const sessionOutputSchema = z.object({
+  session_id: z.string(),
+  context_id: z.string(),
+  page_id: z.string(),
+  status: z.enum(["active", "closing", "closed", "error"]),
+  profile_mode: profileModeSchema,
+  locale: z.string().optional(),
+  timezone_id: z.string().optional(),
+  user_data_dir: z.string().optional(),
+  profile_directory: z.string().optional(),
+  humanize: z.boolean(),
+  launch_args: z.array(z.string()),
+  viewport: viewportSchema,
+  created_at: z.string(),
+  health: z.object({
+    consecutive_errors: z.number().int().nonnegative(),
+    last_error_at: z.string().optional(),
+    restart_recommended: z.boolean()
+  }),
+  capabilities: z.object({
+    observe: z.boolean(),
+    screenshot: z.boolean(),
+    evaluate: z.boolean()
+  })
+});
+
+export const sessionCloseOutputSchema = z.object({
+  session_id: z.string(),
+  closed: z.boolean(),
+  status: z.enum(["active", "closing", "closed", "error"])
+});
+
+export const sessionRestartOutputSchema = sessionOutputSchema;
+
+export type CreateSessionInput = z.infer<typeof createSessionInputSchema>;