opencode-pair-autonomy 1.0.0

package/vendor/mcp/web-agent-mcp/src/tools/observe/text.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { observeSessionInputSchema, observeTextOutputSchema } from "../../schemas/observe.js";
+
+const observeTextInputSchema = observeSessionInputSchema.extend({
+  format: z.enum(["text", "markdown"]).default("text")
+});
+
+export function registerObserveTextTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.text",
+    {
+      title: "Observe Text",
+      description: "Return extracted page text as a cheap observation artifact.",
+      inputSchema: observeTextInputSchema,
+      outputSchema: observeTextOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof observeTextInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.text", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.observeText(
+          input.session_id,
+          input.page_id,
+          input.format
+        );
+        const artifact = await services.artifacts.writeText(input.format, result.content, {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title,
+          meta: { requested_format: input.format, truncated: result.truncated }
+        });
+        const data = {
+          artifact_id: artifact.artifact_id,
+          format: input.format,
+          content: result.content,
+          truncated: result.truncated,
+          url: result.url,
+          title: result.title,
+          follow_up_by_goal: buildFollowUpByGoal({
+            pageStateKnown: true,
+            targetSelectorKnown: false,
+            recentFailure: "none"
+          })
+        };
+        await services.history.finishAction(action, "succeeded", {
+          artifact_id: artifact.artifact_id,
+          truncated: result.truncated
+        });
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, page_id: page.pageId, artifact_ids: [artifact.artifact_id], data });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/observe/wait-for-network.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createFailureResult } from "../../core/errors.js";
+import {
+  waitForNetworkInputSchema,
+  waitForNetworkOutputSchema
+} from "../../schemas/observe.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import type { RuntimeServices } from "../../server.js";
+
+export function registerWaitForNetworkTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "observe.wait_for_network",
+    {
+      title: "Wait For Network",
+      description: "Wait for a matching network response or failure in the active page session.",
+      inputSchema: waitForNetworkInputSchema,
+      outputSchema: waitForNetworkOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof waitForNetworkInputSchema>) => {
+      try {
+        const action = await services.history.startAction("observe.wait_for_network", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.waitForNetwork(
+          input.session_id,
+          input.page_id,
+          {
+            urlPattern: input.url_pattern,
+            useRegex: input.use_regex,
+            status: input.status,
+            outcome: input.outcome,
+            timeoutMs: input.timeout_ms,
+            pollIntervalMs: input.poll_interval_ms
+          }
+        );
+
+        const data = {
+          entry: result.entry,
+          elapsed_ms: result.elapsedMs
+        };
+
+        await services.history.finishAction(action, "succeeded", {
+          elapsed_ms: result.elapsedMs,
+          matched_url: result.entry.url,
+          status: result.entry.status,
+          outcome: result.entry.outcome
+        });
+
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/page/navigate.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildFollowUpByGoal } from "../../core/observation-flow.js";
+import type { RuntimeServices } from "../../server.js";
+import { createId } from "../../utils/ids.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { navigatePageInputSchema, navigatePageOutputSchema } from "../../schemas/page.js";
+
+export function registerNavigatePageTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "page.navigate",
+    {
+      title: "Navigate Page",
+      description: "Navigate the active page to a URL and return lightweight metadata.",
+      inputSchema: navigatePageInputSchema,
+      outputSchema: navigatePageOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof navigatePageInputSchema>) => {
+      try {
+        const action = await services.history.startAction("page.navigate", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.navigate(
+          input.session_id,
+          input.page_id,
+          input.url,
+          input.wait_until
+        );
+        const response = {
+          page_id: page.pageId,
+          requested_url: result.requestedUrl,
+          final_url: result.finalUrl,
+          title: result.title,
+          navigation_id: createId("action"),
+          timings: {
+            elapsed_ms: result.elapsedMs
+          },
+          follow_up_by_goal: buildFollowUpByGoal({
+            pageStateKnown: false,
+            targetSelectorKnown: false,
+            recentFailure: "none"
+          })
+        };
+        await services.history.finishAction(action, "succeeded", response);
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, page_id: page.pageId, data: response });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/policy/recommend-observation.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { recommendObservation } from "../../core/policy-engine.js";
+import { toPolicyEnvelope } from "../../core/observation-flow.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import {
+  recommendObservationInputSchema,
+  recommendObservationOutputSchema
+} from "../../schemas/policy.js";
+
+export function registerRecommendObservationTool(server: McpServer) {
+  server.registerTool(
+    "policy.recommend_observation",
+    {
+      title: "Recommend Observation",
+      description: "Recommend the cheapest next observation tool before an interaction or verification step.",
+      inputSchema: recommendObservationInputSchema,
+      outputSchema: recommendObservationOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof recommendObservationInputSchema>) => {
+      try {
+        const result = recommendObservation(input);
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          data: toPolicyEnvelope(result)
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/register-tools.ts

@@ -0,0 +1,55 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../server.js";
+import { registerClickTool } from "./act/click.js";
+import { registerDragTool } from "./act/drag.js";
+import { registerEnterCodeTool } from "./act/enter-code.js";
+import { registerFillTool } from "./act/fill.js";
+import { registerPinchTool } from "./act/pinch.js";
+import { registerPressTool } from "./act/press.js";
+import { registerSwipeTool } from "./act/swipe.js";
+import { registerWaitForTool } from "./act/wait-for.js";
+import { registerWheelTool } from "./act/wheel.js";
+import { registerNavigatePageTool } from "./page/navigate.js";
+import { registerObserveA11yTool } from "./observe/a11y.js";
+import { registerObserveAuthStateTool } from "./observe/auth-state.js";
+import { registerObserveBoxesTool } from "./observe/boxes.js";
+import { registerObserveConsoleTool } from "./observe/console.js";
+import { registerObserveDomTool } from "./observe/dom.js";
+import { registerObserveNetworkTool } from "./observe/network.js";
+import { registerObservePageStateTool } from "./observe/page-state.js";
+import { registerObserveScreenshotTool } from "./observe/screenshot.js";
+import { registerObserveTextTool } from "./observe/text.js";
+import { registerWaitForNetworkTool } from "./observe/wait-for-network.js";
+import { registerRecommendObservationTool } from "./policy/recommend-observation.js";
+import { registerEvaluateJsTool } from "./runtime/evaluate-js.js";
+import { registerCloseSessionTool } from "./session/close.js";
+import { registerCreateSessionTool } from "./session/create.js";
+import { registerRestartSessionTool } from "./session/restart.js";
+
+export function registerTools(server: McpServer, services: RuntimeServices) {
+  registerCreateSessionTool(server, services);
+  registerCloseSessionTool(server, services);
+  registerRestartSessionTool(server, services);
+  registerNavigatePageTool(server, services);
+  registerClickTool(server, services);
+  registerDragTool(server, services);
+  registerEnterCodeTool(server, services);
+  registerFillTool(server, services);
+  registerPinchTool(server, services);
+  registerPressTool(server, services);
+  registerSwipeTool(server, services);
+  registerWaitForTool(server, services);
+  registerWheelTool(server, services);
+  registerObserveA11yTool(server, services);
+  registerObserveAuthStateTool(server, services);
+  registerObserveBoxesTool(server, services);
+  registerObserveConsoleTool(server, services);
+  registerObserveDomTool(server, services);
+  registerObserveNetworkTool(server, services);
+  registerObservePageStateTool(server, services);
+  registerObserveTextTool(server, services);
+  registerObserveScreenshotTool(server, services);
+  registerWaitForNetworkTool(server, services);
+  registerRecommendObservationTool(server);
+  registerEvaluateJsTool(server, services);
+}

package/vendor/mcp/web-agent-mcp/src/tools/runtime/evaluate-js.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { evaluateJsInputSchema, evaluateJsOutputSchema } from "../../schemas/runtime.js";
+
+const INLINE_LIMIT = 8000;
+
+export function registerEvaluateJsTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "runtime.evaluate_js",
+    {
+      title: "Evaluate Runtime JavaScript",
+      description: "Evaluate a JavaScript expression in the current page context and persist the result as an artifact.",
+      inputSchema: evaluateJsInputSchema,
+      outputSchema: evaluateJsOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof evaluateJsInputSchema>) => {
+      try {
+        const action = await services.history.startAction("runtime.evaluate_js", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.evaluateJs(
+          input.session_id,
+          input.page_id,
+          {
+            expression: input.expression,
+            awaitPromise: input.await_promise
+          }
+        );
+
+        const serialized = JSON.stringify(result.value, null, 2);
+        const artifact = await services.artifacts.writeText("eval", serialized, {
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          action_id: action.action_id,
+          url: result.url,
+          title: result.title,
+          meta: {
+            await_promise: input.await_promise,
+            inline: serialized.length <= INLINE_LIMIT
+          }
+        });
+
+        const data = {
+          artifact_id: artifact.artifact_id,
+          value: serialized.length <= INLINE_LIMIT ? result.value : undefined,
+          preview: serialized.length <= INLINE_LIMIT ? undefined : `${serialized.slice(0, INLINE_LIMIT)}...`,
+          truncated: serialized.length > INLINE_LIMIT,
+          url: result.url,
+          title: result.title,
+          bytes: artifact.bytes,
+          storage_path: artifact.storage_path
+        };
+
+        await services.history.finishAction(action, "succeeded", {
+          artifact_id: artifact.artifact_id,
+          truncated: data.truncated
+        });
+
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: page.pageId,
+          artifact_ids: [artifact.artifact_id],
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/session/close.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import { closeSessionInputSchema, sessionCloseOutputSchema } from "../../schemas/session.js";
+
+export function registerCloseSessionTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "session.close",
+    {
+      title: "Close Session",
+      description: "Close a browser session and release its runtime resources.",
+      inputSchema: closeSessionInputSchema,
+      outputSchema: sessionCloseOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof closeSessionInputSchema>) => {
+      try {
+        const action = await services.history.startAction("session.close", input, {
+          session_id: input.session_id
+        });
+        const session = await services.sessions.closeSession(input.session_id);
+        const data = {
+          session_id: session.sessionId,
+          closed: true,
+          status: session.status
+        };
+        await services.history.finishAction(action, "succeeded", data);
+        return createToolSuccess({ ok: true, code: "OK", action_id: action.action_id, session_id: session.sessionId, data });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/session/create.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import {
+  createSessionInputSchema,
+  sessionOutputSchema,
+} from "../../schemas/session.js";
+
+export function registerCreateSessionTool(
+  server: McpServer,
+  services: RuntimeServices,
+) {
+  server.registerTool(
+    "session.create",
+    {
+      title: "Create Session",
+      description: "Launch a browser session and create the initial page.",
+      inputSchema: createSessionInputSchema,
+      outputSchema: sessionOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (input: z.infer<typeof createSessionInputSchema>) => {
+      try {
+        const action = await services.history.startAction(
+          "session.create",
+          input,
+        );
+        const profileMode = input.profile_mode ?? "persistent";
+        const session = await services.sessions.createSession({
+          profileMode,
+          locale: input.locale,
+          timezoneId: input.timezone_id,
+          userDataDir: input.user_data_dir,
+          profileDirectory: input.profile_directory,
+          humanize: input.humanize,
+          launchArgs: input.launch_args,
+          viewport: input.viewport,
+        });
+        const data = {
+          session_id: session.sessionId,
+          context_id: session.contextId,
+          page_id: session.primaryPageId,
+          status: session.status,
+          profile_mode: session.profileMode,
+          locale: session.locale,
+          timezone_id: session.timezoneId,
+          user_data_dir: session.userDataDir,
+          profile_directory: session.profileDirectory,
+          humanize: session.humanize,
+          launch_args: session.launchArgs,
+          viewport: session.viewport,
+          created_at: session.createdAt,
+          health: {
+            consecutive_errors: session.consecutiveErrors,
+            last_error_at: session.lastErrorAt,
+            restart_recommended: false,
+          },
+          capabilities: {
+            observe: true,
+            screenshot: true,
+            evaluate: true,
+          },
+        };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: session.primaryPageId,
+          data,
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    },
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/session/restart.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { createFailureResult } from "../../core/errors.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import {
+  restartSessionInputSchema,
+  sessionRestartOutputSchema
+} from "../../schemas/session.js";
+
+export function registerRestartSessionTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "session.restart",
+    {
+      title: "Restart Session",
+      description: "Restart a browser session while preserving its launch profile settings.",
+      inputSchema: restartSessionInputSchema,
+      outputSchema: sessionRestartOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (input: z.infer<typeof restartSessionInputSchema>) => {
+      try {
+        const action = await services.history.startAction("session.restart", input, {
+          session_id: input.session_id
+        });
+        const session = await services.sessions.restartSession(input.session_id);
+        const health = services.sessions.getSessionHealth(session.sessionId);
+        const data = {
+          session_id: session.sessionId,
+          context_id: session.contextId,
+          page_id: session.primaryPageId,
+          status: session.status,
+          profile_mode: session.profileMode,
+          locale: session.locale,
+          timezone_id: session.timezoneId,
+          user_data_dir: session.userDataDir,
+          profile_directory: session.profileDirectory,
+          humanize: session.humanize,
+          launch_args: session.launchArgs,
+          viewport: session.viewport,
+          created_at: session.createdAt,
+          health: {
+            consecutive_errors: health.consecutiveErrors,
+            last_error_at: health.lastErrorAt,
+            restart_recommended: health.restartRecommended
+          },
+          capabilities: {
+            observe: true,
+            screenshot: true,
+            evaluate: true
+          }
+        };
+        await services.history.finishAction(action, "succeeded", data);
+        return createToolSuccess({
+          ok: true,
+          code: "OK",
+          action_id: action.action_id,
+          session_id: session.sessionId,
+          page_id: session.primaryPageId,
+          data
+        });
+      } catch (error) {
+        return createFailureResult(error);
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/utils/fs.ts

@@ -0,0 +1,28 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function ensureDir(dirPath: string) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function appendJsonLine(filePath: string, value: unknown) {
+  await ensureDir(path.dirname(filePath));
+  await fs.appendFile(filePath, `${JSON.stringify(value)}\n`, "utf8");
+}
+
+export async function readJsonFile<T>(filePath: string, fallback: T): Promise<T> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw) as T;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+
+export async function writeJsonFile(filePath: string, value: unknown) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}

package/vendor/mcp/web-agent-mcp/src/utils/ids.ts

@@ -0,0 +1,9 @@
+type IdPrefix = "session" | "context" | "page" | "task" | "action" | "artifact";
+
+function randomPart() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+export function createId(prefix: IdPrefix) {
+  return `${prefix}_${Date.now().toString(36)}_${randomPart()}`;
+}

package/vendor/mcp/web-agent-mcp/src/utils/time.ts

@@ -0,0 +1,7 @@
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function elapsedMs(startedAt: number) {
+  return Date.now() - startedAt;
+}

package/vendor/mcp/web-agent-mcp/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "rootDir": ".",
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}