@canaryai/cli 0.2.3 → 0.2.4

package/dist/mcp-HGYBMDYZ.js

@@ -0,0 +1,687 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  connectTunnel,
+  createLocalRun,
+  createTunnel
+} from "./chunk-DXIAHB72.js";
+import {
+  LocalBrowserHost
+} from "./chunk-FIQBGAKW.js";
+import {
+  readStoredToken
+} from "./chunk-PWWQGYFG.js";
+import "./chunk-VLFUCAPZ.js";
+
+// src/mcp/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/tool-helpers.ts
+function toolText(text) {
+  return { content: [{ type: "text", text }] };
+}
+function toolJson(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function formatMCPContent(result) {
+  if (typeof result === "string") {
+    return { content: [{ type: "text", text: result }] };
+  }
+  const content = [];
+  if (result.text) {
+    content.push({ type: "text", text: result.text });
+  }
+  for (const img of result.images ?? []) {
+    content.push({ type: "image", data: img.data, mimeType: img.mimeType });
+  }
+  return { content };
+}
+
+// src/mcp/session-tools.ts
+import { createParser } from "eventsource-parser";
+import process2 from "process";
+var browserSessions = /* @__PURE__ */ new Map();
+var DEFAULT_API_URL = "https://api.trycanary.ai";
+function resolveApiUrl(input) {
+  return input ?? process2.env.CANARY_API_URL ?? DEFAULT_API_URL;
+}
+async function resolveToken() {
+  const token = process2.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    throw new Error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+  }
+  return token;
+}
+function getSessionToolDefinitions() {
+  return [
+    {
+      name: "local_run_tests",
+      description: "Start an async local test run. A tunnel is opened automatically. Returns runId and watchUrl.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          port: { type: "number" },
+          instructions: { type: "string" },
+          title: { type: "string" }
+        },
+        required: ["port", "instructions"]
+      }
+    },
+    {
+      name: "local_wait_for_results",
+      description: "Wait for a local test run to complete. Streams until completion and returns a compact report.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          runId: { type: "string" }
+        },
+        required: ["runId"]
+      }
+    },
+    {
+      name: "local_browser_start",
+      description: "Start a local browser session that connects to the cloud agent. The cloud agent can then control this browser to test local applications. Returns sessionId for tracking.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["playwright", "cdp"],
+            description: "Browser mode: 'playwright' for fresh browser, 'cdp' to connect to existing Chrome"
+          },
+          cdpUrl: {
+            type: "string",
+            description: "CDP endpoint URL when mode is 'cdp' (e.g. http://localhost:9222)"
+          },
+          headless: {
+            type: "boolean",
+            description: "Run browser headless (default: true for playwright mode)"
+          },
+          storageStatePath: {
+            type: "string",
+            description: "Path to Playwright storage state JSON for pre-authenticated sessions"
+          },
+          instructions: {
+            type: "string",
+            description: "Instructions for the cloud agent on what to test"
+          }
+        }
+      }
+    },
+    {
+      name: "local_browser_status",
+      description: "Check the status of a local browser session.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sessionId: { type: "string" }
+        },
+        required: ["sessionId"]
+      }
+    },
+    {
+      name: "local_browser_stop",
+      description: "Stop a local browser session and close the browser.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sessionId: { type: "string" }
+        },
+        required: ["sessionId"]
+      }
+    },
+    {
+      name: "local_browser_list",
+      description: "List all active local browser sessions.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "local_browser_run",
+      description: "Start a test run on an active local browser session. The cloud agent will control the local browser according to the instructions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sessionId: {
+            type: "string",
+            description: "The session ID from local_browser_start"
+          },
+          instructions: {
+            type: "string",
+            description: "Instructions for the cloud agent on what to test"
+          },
+          startUrl: {
+            type: "string",
+            description: "Optional URL to navigate to before starting"
+          }
+        },
+        required: ["sessionId", "instructions"]
+      }
+    }
+  ];
+}
+async function handleSessionTool(tool, args) {
+  const token = await resolveToken();
+  if (tool === "local_run_tests") {
+    const input = args;
+    const apiUrl = resolveApiUrl();
+    const tunnel = await createTunnel({ apiUrl, token, port: input.port });
+    connectTunnel({
+      apiUrl,
+      tunnelId: tunnel.tunnelId,
+      token: tunnel.token,
+      port: input.port
+    });
+    const tunnelUrl = tunnel.publicUrl;
+    const run = await createLocalRun({
+      apiUrl,
+      token,
+      title: input.title ?? "Local MCP run",
+      featureSpec: input.instructions,
+      startUrl: void 0,
+      tunnelUrl
+    });
+    return toolJson({
+      runId: run.runId,
+      watchUrl: run.watchUrl,
+      tunnelUrl,
+      note: "Testing is asynchronous. Use local_wait_for_results with the runId to wait for completion."
+    });
+  }
+  if (tool === "local_wait_for_results") {
+    const input = args;
+    const apiUrl = resolveApiUrl();
+    const report = await waitForResult({ apiUrl, token, runId: input.runId });
+    return toolJson(report);
+  }
+  if (tool === "local_browser_start") {
+    const input = args;
+    const apiUrl = resolveApiUrl();
+    const mode = input.mode ?? "playwright";
+    const sessionResponse = await fetch(`${apiUrl}/local-browser/sessions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        browserMode: mode,
+        instructions: input.instructions ?? null
+      })
+    });
+    if (!sessionResponse.ok) {
+      const text = await sessionResponse.text();
+      return toolJson({ ok: false, error: `Failed to create session: ${text}` });
+    }
+    const session = await sessionResponse.json();
+    const host = new LocalBrowserHost({
+      apiUrl,
+      wsToken: session.wsToken,
+      sessionId: session.sessionId,
+      browserMode: mode,
+      cdpUrl: input.cdpUrl,
+      headless: input.headless ?? true,
+      storageStatePath: input.storageStatePath,
+      onLog: (level, message) => {
+        if (level === "error") {
+          console.error(`[LocalBrowser] ${message}`);
+        }
+      }
+    });
+    host.start().catch((err) => {
+      console.error("Failed to start local browser:", err);
+      browserSessions.delete(session.sessionId);
+    });
+    browserSessions.set(session.sessionId, {
+      sessionId: session.sessionId,
+      host,
+      startedAt: Date.now(),
+      mode
+    });
+    return toolJson({
+      ok: true,
+      sessionId: session.sessionId,
+      mode,
+      expiresAt: session.expiresAt,
+      note: "Browser session started. The cloud agent can now control this browser. Use local_browser_stop to end the session."
+    });
+  }
+  if (tool === "local_browser_status") {
+    const input = args;
+    const session = browserSessions.get(input.sessionId);
+    if (!session) {
+      return toolJson({ ok: false, error: "Session not found", sessionId: input.sessionId });
+    }
+    return toolJson({
+      ok: true,
+      sessionId: session.sessionId,
+      mode: session.mode,
+      startedAt: new Date(session.startedAt).toISOString(),
+      uptimeMs: Date.now() - session.startedAt
+    });
+  }
+  if (tool === "local_browser_stop") {
+    const input = args;
+    const session = browserSessions.get(input.sessionId);
+    if (!session) {
+      return toolJson({ ok: false, error: "Session not found", sessionId: input.sessionId });
+    }
+    await session.host.stop();
+    browserSessions.delete(input.sessionId);
+    return toolJson({
+      ok: true,
+      sessionId: input.sessionId,
+      note: "Browser session stopped and browser closed."
+    });
+  }
+  if (tool === "local_browser_list") {
+    const sessions = Array.from(browserSessions.values()).map((s) => ({
+      sessionId: s.sessionId,
+      mode: s.mode,
+      startedAt: new Date(s.startedAt).toISOString(),
+      uptimeMs: Date.now() - s.startedAt
+    }));
+    return toolJson({
+      ok: true,
+      count: sessions.length,
+      sessions
+    });
+  }
+  if (tool === "local_browser_run") {
+    const input = args;
+    const apiUrl = resolveApiUrl();
+    const session = browserSessions.get(input.sessionId);
+    if (!session) {
+      return toolJson({
+        ok: false,
+        error: "Session not found locally. Make sure you started it with local_browser_start.",
+        sessionId: input.sessionId
+      });
+    }
+    const response = await fetch(`${apiUrl}/local-browser/sessions/${input.sessionId}/run`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        instructions: input.instructions,
+        startUrl: input.startUrl ?? null
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      return toolJson({ ok: false, error: `Failed to start run: ${text}` });
+    }
+    const result = await response.json();
+    return toolJson({
+      ok: true,
+      jobId: result.jobId,
+      sessionId: result.sessionId,
+      note: "Test run started. The cloud agent is now controlling your local browser. You can watch the browser to see the test in action."
+    });
+  }
+  return null;
+}
+async function waitForResult(input) {
+  await streamUntilComplete(input);
+  const response = await fetch(`${input.apiUrl}/local-tests/runs/${input.runId}`, {
+    credentials: "include",
+    headers: { authorization: `Bearer ${input.token}` }
+  });
+  const data = await response.json();
+  const run = data?.data?.run ?? data?.run ?? data?.data;
+  const summary = run?.summaryJson;
+  return formatReport({ run, summary });
+}
+async function streamUntilComplete(input) {
+  const response = await fetch(`${input.apiUrl}/local-tests/runs/${input.runId}/stream`, {
+    headers: { authorization: `Bearer ${input.token}` }
+  });
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const parser = createParser({
+    onEvent: (event) => {
+      if (event.event === "status") {
+        try {
+          const payload = JSON.parse(event.data);
+          if (payload?.status === "completed" || payload?.status === "failed") {
+            reader.cancel().catch(() => void 0);
+          }
+        } catch {
+        }
+      }
+      if (event.event === "complete" || event.event === "error") {
+        reader.cancel().catch(() => void 0);
+      }
+    }
+  });
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value, { stream: true }));
+  }
+}
+function formatReport(input) {
+  if (!input.summary) {
+    return {
+      runId: input.run?.id,
+      status: input.run?.status ?? "unknown",
+      summary: "No final report available."
+    };
+  }
+  const tested = Array.isArray(input.summary.testedItems) ? input.summary.testedItems : [];
+  const status = input.summary.status ?? input.run?.status ?? "unknown";
+  const issues = status === "issues_found" ? input.summary.notes ? [input.summary.notes] : ["Issues reported."] : [];
+  return {
+    runId: input.run?.id,
+    status,
+    summary: input.summary.summary ?? "Run completed.",
+    testedItems: tested,
+    issues,
+    notes: input.summary.notes ?? null
+  };
+}
+
+// src/mcp/browser-tools.ts
+import { getBrowserToolDefinitionsWithLifecycle } from "@chatsdet/browser-core";
+
+// src/mcp/browser-session.ts
+import {
+  PlaywrightClient,
+  BrowserToolExecutor,
+  consoleLogger
+} from "@chatsdet/browser-core";
+var activeSession = null;
+async function startDirectBrowser(opts) {
+  if (activeSession) {
+    throw new Error("A browser session is already active. Stop it first with browser_stop.");
+  }
+  const client = new PlaywrightClient({
+    logger: consoleLogger
+  });
+  await client.connect({
+    browserMode: opts?.headless ? "headless" : "headed",
+    storageStatePath: opts?.storageStatePath
+  });
+  const executor = new BrowserToolExecutor(client, {
+    autoSnapshotAfterAction: true,
+    includeScreenshotWithSnapshot: true,
+    clickValidation: true,
+    logger: consoleLogger,
+    ...opts?.executorOptions
+  });
+  activeSession = {
+    client,
+    executor,
+    startedAt: Date.now()
+  };
+  const cleanup = async () => {
+    if (activeSession) {
+      try {
+        await activeSession.client.disconnect();
+      } catch {
+      }
+      activeSession = null;
+    }
+  };
+  process.on("exit", () => {
+    cleanup();
+  });
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  return activeSession;
+}
+async function stopDirectBrowser() {
+  if (!activeSession) {
+    throw new Error("No active browser session to stop.");
+  }
+  await activeSession.client.disconnect();
+  activeSession = null;
+}
+function requireDirectBrowser() {
+  if (!activeSession) {
+    throw new Error("No active browser session. Start one with browser_start first.");
+  }
+  return activeSession;
+}
+
+// src/mcp/browser-tools.ts
+function getBrowserMCPToolDefinitions() {
+  return getBrowserToolDefinitionsWithLifecycle();
+}
+async function handleBrowserTool(name, args) {
+  if (name === "browser_start") {
+    try {
+      await startDirectBrowser({
+        headless: args.headless ?? false,
+        storageStatePath: args.storageStatePath
+      });
+      return toolJson({
+        ok: true,
+        note: "Browser started. You can now use browser_navigate, browser_click, and other browser tools."
+      });
+    } catch (err) {
+      return toolJson({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  if (name === "browser_stop") {
+    try {
+      await stopDirectBrowser();
+      return toolJson({ ok: true, note: "Browser stopped and cleaned up." });
+    } catch (err) {
+      return toolJson({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  if (!name.startsWith("browser_")) return null;
+  let session;
+  try {
+    session = requireDirectBrowser();
+  } catch (err) {
+    return toolJson({ ok: false, error: err instanceof Error ? err.message : String(err) });
+  }
+  const executor = session.executor;
+  try {
+    switch (name) {
+      case "browser_navigate":
+        return formatMCPContent(await executor.navigate(args.url));
+      case "browser_navigate_back":
+        return formatMCPContent(await executor.navigateBack());
+      case "browser_snapshot":
+        return formatMCPContent(
+          await executor.snapshot({
+            mode: args.mode,
+            expand: args.expand,
+            search: args.search,
+            showCoordinateGrid: args.showCoordinateGrid,
+            probeAt: args.probeAt
+          })
+        );
+      case "browser_screenshot":
+        return formatMCPContent(
+          await executor.screenshot({
+            fullPage: args.fullPage,
+            element: args.element,
+            ref: args.ref,
+            label: args.label,
+            returnImage: args.returnImage
+          })
+        );
+      case "browser_evaluate":
+        return formatMCPContent(
+          await executor.evaluate({
+            expression: args.function,
+            element: args.element,
+            ref: args.ref
+          })
+        );
+      case "browser_console_messages":
+        return formatMCPContent(
+          await executor.consoleMessages({ onlyErrors: args.onlyErrors })
+        );
+      case "browser_network_requests":
+        return formatMCPContent(await executor.networkRequests());
+      case "browser_click":
+        return formatMCPContent(
+          await executor.click({
+            ref: args.ref,
+            x: args.x,
+            y: args.y,
+            element: args.element,
+            doubleClick: args.doubleClick,
+            button: args.button,
+            modifiers: args.modifiers
+          })
+        );
+      case "browser_hover":
+        return formatMCPContent(
+          await executor.hover({
+            ref: args.ref,
+            element: args.element
+          })
+        );
+      case "browser_drag":
+        return formatMCPContent(
+          await executor.drag({
+            startRef: args.startRef,
+            endRef: args.endRef,
+            startElement: args.startElement,
+            endElement: args.endElement,
+            startX: args.startX,
+            startY: args.startY,
+            endX: args.endX,
+            endY: args.endY
+          })
+        );
+      case "browser_type":
+        return formatMCPContent(
+          await executor.type({
+            ref: args.ref,
+            text: args.text,
+            element: args.element,
+            submit: args.submit,
+            delay: args.delay
+          })
+        );
+      case "browser_press_key":
+        return formatMCPContent(await executor.pressKey(args.key));
+      case "browser_fill_form":
+        return formatMCPContent(
+          await executor.fillForm(
+            args.fields
+          )
+        );
+      case "browser_select_option":
+        return formatMCPContent(
+          await executor.selectOption({
+            ref: args.ref,
+            value: args.value,
+            element: args.element
+          })
+        );
+      case "browser_file_upload":
+        return formatMCPContent(await executor.fileUpload(args.paths));
+      case "browser_scroll":
+        return formatMCPContent(
+          await executor.scroll({
+            direction: args.direction,
+            amount: args.amount,
+            withinRef: args.withinRef,
+            toRef: args.toRef,
+            x: args.x,
+            y: args.y
+          })
+        );
+      case "browser_handle_dialog":
+        return formatMCPContent(
+          await executor.handleDialog({
+            action: args.action,
+            promptText: args.promptText
+          })
+        );
+      case "browser_dismiss_overlay":
+        return formatMCPContent(
+          await executor.dismissOverlay({
+            preferredStrategy: args.preferredStrategy
+          })
+        );
+      case "browser_wait_for":
+        return formatMCPContent(
+          await executor.waitFor({
+            timeSec: args.time,
+            text: args.text,
+            textGone: args.textGone,
+            selector: args.selector,
+            state: args.state,
+            timeout: args.timeout
+          })
+        );
+      case "browser_close":
+        return formatMCPContent(await executor.close());
+      case "browser_resize":
+        return formatMCPContent(
+          await executor.resize(args.width, args.height)
+        );
+      case "browser_tabs":
+        return formatMCPContent(
+          await executor.tabs({
+            action: args.action,
+            index: args.index
+          })
+        );
+      case "browser_list_downloads":
+        return formatMCPContent(await executor.listDownloads());
+      case "browser_read_download":
+        return formatMCPContent(
+          await executor.readDownload(args.downloadId)
+        );
+      case "browser_pdf_read":
+        return formatMCPContent(await executor.fetchPdfText(args.url));
+      default:
+        return toolText(`Unknown browser tool: ${name}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return toolJson({ ok: false, error: message, tool: name });
+  }
+}
+
+// src/mcp/index.ts
+async function runMcp(argv) {
+  const server = new Server(
+    { name: "canary-cli", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      ...getSessionToolDefinitions(),
+      ...getBrowserMCPToolDefinitions()
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = req.params.name;
+    const args = req.params.arguments ?? {};
+    const browserResult = await handleBrowserTool(tool, args);
+    if (browserResult) return browserResult;
+    const sessionResult = await handleSessionTool(tool, args);
+    if (sessionResult) return sessionResult;
+    return toolText(`Unknown tool: ${tool}`);
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  return new Promise(() => void 0);
+}
+export {
+  runMcp
+};
+//# sourceMappingURL=mcp-HGYBMDYZ.js.map