opencode-pair-autonomy 1.0.0

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

@@ -0,0 +1,75 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
+import { loadEnv } from "./config/env.js";
+import { createCloakBrowserAdapter } from "./adapters/cloakbrowser/launcher.js";
+import { ArtifactStore } from "./core/artifact-store.js";
+import { SessionManager } from "./core/session-manager.js";
+import { TaskHistoryStore } from "./core/task-history.js";
+import { registerTools } from "./tools/register-tools.js";
+
+export type RuntimeServices = {
+  env: ReturnType<typeof loadEnv>;
+  artifacts: ArtifactStore;
+  history: TaskHistoryStore;
+  sessions: SessionManager;
+};
+
+export function createRuntimeServices() {
+  const env = loadEnv();
+  const artifacts = new ArtifactStore(env);
+  const history = new TaskHistoryStore(env);
+  const adapter = createCloakBrowserAdapter(env);
+  const sessions = new SessionManager({ env, adapter });
+
+  return { env, artifacts, history, sessions } satisfies RuntimeServices;
+}
+
+export function createServer(services = createRuntimeServices()) {
+  const server = new McpServer(
+    {
+      name: services.env.serverName,
+      version: services.env.serverVersion,
+    },
+    {
+      capabilities: {
+        logging: {},
+      },
+    },
+  );
+
+  registerTools(server, services);
+  return server;
+}
+
+export async function startStdioServer() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("web-agent-mcp running on stdio");
+}
+
+async function main() {
+  await startStdioServer();
+}
+
+function isMainModule(): boolean {
+  if (!process.argv[1]) return false;
+  const argv1Url = pathToFileURL(process.argv[1]).href;
+  if (import.meta.url === argv1Url) return true;
+  try {
+    return (
+      import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+  });
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/click.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, clickInputSchema } from "../../schemas/act.js";
+import {
+  createActionFailureResponse,
+  createActionSuccessResult,
+} from "./shared.js";
+
+export function registerClickTool(
+  server: McpServer,
+  services: RuntimeServices,
+) {
+  server.registerTool(
+    "act.click",
+    {
+      title: "Click Element",
+      description: "Click an element using a CSS selector.",
+      inputSchema: clickInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input: z.infer<typeof clickInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.click", input, {
+          session_id: input.session_id,
+          page_id: input.page_id,
+        });
+        const { session, page, result } = await services.sessions.click(
+          input.session_id,
+          input.page_id,
+          {
+            selector: input.selector,
+            frameSelector: input.frame_selector,
+            button: input.button,
+            clickCount: input.click_count,
+            timeoutMs: input.timeout_ms,
+          },
+        );
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "semantic",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: true,
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "semantic",
+          targetSelectorKnown: true,
+        });
+      }
+    },
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/drag.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, dragInputSchema } from "../../schemas/act.js";
+import { createActionFailureResponse, createActionSuccessResult } from "./shared.js";
+
+export function registerDragTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.drag",
+    {
+      title: "Drag Between Elements",
+      description: "Drag from one selector to another using mouse input.",
+      inputSchema: dragInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof dragInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.drag", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.drag(input.session_id, input.page_id, {
+          fromSelector: input.from_selector,
+          toSelector: input.to_selector,
+          steps: input.steps,
+          timeoutMs: input.timeout_ms
+        });
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "physical",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: true
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "physical",
+          targetSelectorKnown: true
+        });
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/enter-code.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, enterCodeInputSchema } from "../../schemas/act.js";
+import {
+  createActionFailureResponse,
+  createActionSuccessResult,
+} from "./shared.js";
+
+export function registerEnterCodeTool(
+  server: McpServer,
+  services: RuntimeServices,
+) {
+  server.registerTool(
+    "act.enter_code",
+    {
+      title: "Enter Verification Code",
+      description:
+        "Fill a one-time code into a focused, single, or segmented input flow.",
+      inputSchema: enterCodeInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input: z.infer<typeof enterCodeInputSchema>) => {
+      const action = await services.history.startAction(
+        "act.enter_code",
+        input,
+        {
+          session_id: input.session_id,
+          page_id: input.page_id,
+        },
+      );
+
+      try {
+        const { session, page, result } = await services.sessions.enterCode(
+          input.session_id,
+          input.page_id,
+          {
+            code: input.code,
+            selector: input.selector,
+            frameSelector: input.frame_selector,
+            submit: input.submit,
+            timeoutMs: input.timeout_ms,
+          },
+        );
+
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", {
+          verificationHint: result.verificationHint,
+        });
+
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "semantic",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector),
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          actionId: action.action_id,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "semantic",
+          targetSelectorKnown: Boolean(input.selector),
+        });
+      }
+    },
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/fill.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, fillInputSchema } from "../../schemas/act.js";
+import {
+  createActionFailureResponse,
+  createActionSuccessResult,
+} from "./shared.js";
+
+export function registerFillTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.fill",
+    {
+      title: "Fill Input",
+      description: "Fill a form input using a CSS selector.",
+      inputSchema: fillInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input: z.infer<typeof fillInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.fill", input, {
+          session_id: input.session_id,
+          page_id: input.page_id,
+        });
+        const { session, page, result } = await services.sessions.fill(
+          input.session_id,
+          input.page_id,
+          {
+            selector: input.selector,
+            frameSelector: input.frame_selector,
+            value: input.value,
+            clearFirst: input.clear_first,
+            timeoutMs: input.timeout_ms,
+          },
+        );
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "semantic",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: true,
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "semantic",
+          targetSelectorKnown: true,
+        });
+      }
+    },
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/pinch.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, pinchInputSchema } from "../../schemas/act.js";
+import { createActionFailureResponse, createActionSuccessResult } from "./shared.js";
+
+export function registerPinchTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.pinch",
+    {
+      title: "Pinch Gesture",
+      description: "Perform a touch-style pinch gesture on a selector center or explicit coordinates.",
+      inputSchema: pinchInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof pinchInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.pinch", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.pinch(input.session_id, input.page_id, {
+          selector: input.selector,
+          centerX: input.center_x,
+          centerY: input.center_y,
+          scaleFactor: input.scale_factor,
+          speed: input.speed
+        });
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "physical",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "physical",
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      }
+    }
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/press.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, pressInputSchema } from "../../schemas/act.js";
+import {
+  createActionFailureResponse,
+  createActionSuccessResult,
+} from "./shared.js";
+
+export function registerPressTool(
+  server: McpServer,
+  services: RuntimeServices,
+) {
+  server.registerTool(
+    "act.press",
+    {
+      title: "Press Key",
+      description: "Press a keyboard key on the page or a targeted selector.",
+      inputSchema: pressInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input: z.infer<typeof pressInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.press", input, {
+          session_id: input.session_id,
+          page_id: input.page_id,
+        });
+        const { session, page, result } = await services.sessions.press(
+          input.session_id,
+          input.page_id,
+          {
+            key: input.key,
+            selector: input.selector,
+            frameSelector: input.frame_selector,
+            timeoutMs: input.timeout_ms,
+          },
+        );
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "semantic",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector),
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "semantic",
+          targetSelectorKnown: Boolean(input.selector),
+        });
+      }
+    },
+  );
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/shared.ts

@@ -0,0 +1,73 @@
+import { createFailureResult } from "../../core/errors.js";
+import { buildActionFailurePayload, buildActionSuccessPayload } from "../../core/action-flow.js";
+import { createToolSuccess } from "../../schemas/common.js";
+import type { RuntimeServices } from "../../server.js";
+
+export function createActionSuccessResult(input: {
+  actionId: string;
+  sessionId: string;
+  pageId: string;
+  appliedMode: "semantic" | "physical";
+  verificationHint?: string;
+  targetSelectorKnown: boolean;
+}) {
+  return createToolSuccess({
+    ok: true,
+    code: "OK",
+    action_id: input.actionId,
+    session_id: input.sessionId,
+    page_id: input.pageId,
+    data: buildActionSuccessPayload({
+      actionId: input.actionId,
+      appliedMode: input.appliedMode,
+      verificationHint: input.verificationHint,
+      targetSelectorKnown: input.targetSelectorKnown
+    })
+  });
+}
+
+export function createActionFailureResponse(input: {
+  services: RuntimeServices;
+  error: unknown;
+  actionId?: string;
+  sessionId: string;
+  pageId?: string;
+  appliedMode: "semantic" | "physical";
+  targetSelectorKnown: boolean;
+}) {
+  let sessionHealth:
+    | {
+        consecutiveErrors: number;
+        maxConsecutiveErrors: number;
+        cooldownMs: number;
+        lastRestartAt?: string;
+        now: string;
+      }
+    | undefined;
+
+  try {
+    const session = input.services.sessions.recordFailure(input.sessionId);
+    sessionHealth = {
+      consecutiveErrors: session.consecutiveErrors,
+      maxConsecutiveErrors: input.services.env.sessionMaxConsecutiveErrors,
+      cooldownMs: input.services.env.sessionRestartCooldownMs,
+      lastRestartAt: session.lastRestartAt,
+      now: new Date().toISOString()
+    };
+  } catch {
+    sessionHealth = undefined;
+  }
+
+  return createFailureResult(input.error, {
+    action_id: input.actionId,
+    session_id: input.sessionId,
+    page_id: input.pageId,
+    data: buildActionFailurePayload({
+      error: input.error,
+      actionId: input.actionId,
+      appliedMode: input.appliedMode,
+      targetSelectorKnown: input.targetSelectorKnown,
+      sessionHealth
+    })
+  });
+}

package/vendor/mcp/web-agent-mcp/src/tools/act/swipe.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, swipeInputSchema } from "../../schemas/act.js";
+import { createActionFailureResponse, createActionSuccessResult } from "./shared.js";
+
+export function registerSwipeTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.swipe",
+    {
+      title: "Swipe Gesture",
+      description: "Perform a touch-style swipe from a selector center or explicit coordinates.",
+      inputSchema: swipeInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof swipeInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.swipe", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.swipe(input.session_id, input.page_id, {
+          selector: input.selector,
+          startX: input.start_x,
+          startY: input.start_y,
+          deltaX: input.delta_x,
+          deltaY: input.delta_y,
+          speed: input.speed
+        });
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "physical",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "physical",
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      }
+    }
+  );
+}

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RuntimeServices } from "../../server.js";
+import { actionResultSchema, waitForInputSchema } from "../../schemas/act.js";
+import { createActionFailureResponse, createActionSuccessResult } from "./shared.js";
+
+export function registerWaitForTool(server: McpServer, services: RuntimeServices) {
+  server.registerTool(
+    "act.wait_for",
+    {
+      title: "Wait For Condition",
+      description: "Wait for a selector or text to appear on the current page.",
+      inputSchema: waitForInputSchema,
+      outputSchema: actionResultSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input: z.infer<typeof waitForInputSchema>) => {
+      try {
+        const action = await services.history.startAction("act.wait_for", input, {
+          session_id: input.session_id,
+          page_id: input.page_id
+        });
+        const { session, page, result } = await services.sessions.waitFor(input.session_id, input.page_id, {
+          selector: input.selector,
+          text: input.text,
+          timeoutMs: input.timeout_ms
+        });
+        const data = { verificationHint: result.verificationHint };
+        services.sessions.recordSuccess(session.sessionId);
+        await services.history.finishAction(action, "succeeded", data);
+        return createActionSuccessResult({
+          actionId: action.action_id,
+          sessionId: session.sessionId,
+          pageId: page.pageId,
+          appliedMode: "semantic",
+          verificationHint: result.verificationHint,
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      } catch (error) {
+        return createActionFailureResponse({
+          services,
+          error,
+          sessionId: input.session_id,
+          pageId: input.page_id,
+          appliedMode: "semantic",
+          targetSelectorKnown: Boolean(input.selector)
+        });
+      }
+    }
+  );
+}