@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/e2e/src/replica.ts

@@ -0,0 +1,70 @@
+/**
+ * What every case needs: the local replica `global-setup.ts` found, the
+ * deployed `hello_actor`, and Ed25519 identities to call as.
+ */
+import type { AuthLike, ReactorError } from "@ic-reactor/core"
+import { isReactorError } from "@ic-reactor/core"
+import type { Identity } from "@icp-sdk/core/agent"
+import { Ed25519KeyIdentity } from "@icp-sdk/core/identity"
+import { inject } from "vitest"
+
+export const replica = inject("replica")
+
+/** The local replica, its root key left to the client (fetched: the host is local). */
+export const network = { host: replica.host } as const
+
+/** `hello_actor` by id. */
+export const target = { id: replica.canisterId } as const
+
+export const ANONYMOUS = "2vxsx-fae"
+
+/** A fresh Ed25519 identity: each case calls as principals no other case uses. */
+export const ed25519 = (): Identity => Ed25519KeyIdentity.generate()
+
+/**
+ * A sign-in that is always signed in, as whichever identity `switchTo` last
+ * named, and tells the client each time it changes.
+ */
+export function switchableAuth(first: Identity): {
+  auth: AuthLike
+  switchTo(next: Identity): void
+} {
+  let current = first
+  const listeners = new Set<() => void>()
+  const auth: AuthLike = {
+    getPrincipal: () => current.getPrincipal(),
+    getStatus: () => ({ state: "signed-in" }),
+    getIdentity: async () => current,
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    signIn: async () => undefined,
+    signOut: async () => undefined,
+  }
+  return {
+    auth,
+    switchTo(next) {
+      current = next
+      for (const listener of listeners) listener()
+    },
+  }
+}
+
+/** The `ReactorError` `promise` rejects with; fails the case when it resolves or rejects with anything else. */
+export async function rejection(
+  promise: Promise<unknown>
+): Promise<ReactorError<unknown>> {
+  let value: unknown
+  try {
+    value = await promise
+  } catch (error) {
+    if (isReactorError(error)) return error
+    throw new Error(`expected a ReactorError, got ${String(error)}`, {
+      cause: error,
+    })
+  }
+  throw new Error(
+    `expected a ReactorError, but the call resolved with ${String(value)}`
+  )
+}

package/e2e/src/vite-env.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `ic_env` resolution through the Vite plugin's dev server: a page served by
+ * `vite dev` with @ic-reactor/vite-plugin gets the cookie that names
+ * `hello_actor` and carries the replica's root key, and its calls reach the
+ * replica through the server's `/api` proxy.
+ */
+import path from "node:path"
+import { createClient } from "@ic-reactor/core"
+import { icReactor } from "@ic-reactor/vite-plugin"
+import { createServer, type ViteDevServer } from "vite"
+import { afterAll, beforeAll, describe, expect, it } from "vitest"
+import { actor, type Actor } from "./declarations/hello_actor"
+import { replica } from "./replica"
+
+/** The JSDOM instance vitest's jsdom environment exposes. */
+const { jsdom } = globalThis as unknown as {
+  jsdom: { reconfigure(options: { url: string }): void }
+}
+
+let server: ViteDevServer | undefined
+let origin = ""
+
+beforeAll(async () => {
+  server = await createServer({
+    configFile: false,
+    // e2e/, whose icp.yaml is the project the plugin asks `icp` about.
+    root: path.resolve(import.meta.dirname, ".."),
+    // Vitest's own mode is "test", in which the plugin injects nothing.
+    mode: "development",
+    logLevel: "silent",
+    appType: "custom",
+    optimizeDeps: { noDiscovery: true, include: [] },
+    server: { host: "127.0.0.1", port: 0, watch: null, hmr: false },
+    // Named only: the cookie carries its id; nothing is generated.
+    plugins: [icReactor({ canisters: { hello_actor: {} } })],
+  })
+  await server.listen()
+  const address = server.httpServer?.address()
+  if (address === null || typeof address !== "object") {
+    throw new Error("the Vite dev server has no address")
+  }
+  origin = `http://127.0.0.1:${address.port}`
+})
+
+afterAll(async () => {
+  await server?.close()
+})
+
+describe("ic_env through the Vite plugin's dev server", () => {
+  it("resolves { name } from the cookie a page load sets, and calls through /api", async () => {
+    // Load the page the way a browser navigates to it.
+    const page = await fetch(`${origin}/`, { headers: { accept: "text/html" } })
+    const cookie = page.headers
+      .getSetCookie()
+      .find((line) => line.startsWith("ic_env="))
+    expect(cookie, "the dev server set no ic_env cookie").toBeDefined()
+    const value = decodeURIComponent(
+      cookie!.split(";")[0].slice("ic_env=".length)
+    )
+    expect(value).toContain(
+      `PUBLIC_CANISTER_ID:hello_actor=${replica.canisterId}`
+    )
+    expect(value).toContain(`ic_root_key=${replica.rootKey}`)
+
+    // This test is that page now: its origin, and the cookie the server set.
+    jsdom.reconfigure({ url: `${origin}/` })
+    document.cookie = cookie!
+    expect(window.location.origin).toBe(origin)
+
+    // Every URL the client's agent requests.
+    const requested: string[] = []
+    const client = createClient({
+      network: "env",
+      identity: "anonymous",
+      fetch: (input, init) => {
+        requested.push(input instanceof Request ? input.url : String(input))
+        return fetch(input, init)
+      },
+    })
+    try {
+      const hello = client.canister<Actor>(actor, { name: "hello_actor" })
+      // The page's origin is the agent's host, so the call goes to the dev
+      // server's /api, which forwards it to the replica.
+      await expect(hello.greet("Vite")).resolves.toBe("Hello, Vite!")
+      expect(
+        requested.some(
+          (url) =>
+            url.startsWith(`${origin}/api/`) &&
+            url.includes(`/canister/${replica.canisterId}/`)
+        ),
+        "the call did not go through the dev server's /api"
+      ).toBe(true)
+      // The root key is the cookie's: the client never asks for one. A client
+      // that ignored the cookie's key would fetch it from /api/v2/status.
+      expect(requested.filter((url) => url.endsWith("/api/v2/status"))).toEqual(
+        []
+      )
+      expect(client.queryKey(hello, "greet", "Vite").slice(0, 4)).toEqual([
+        "ic-reactor",
+        origin,
+        "2vxsx-fae",
+        replica.canisterId,
+      ])
+    } finally {
+      client.dispose()
+    }
+  })
+})

package/e2e/test.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Runs the e2e suite on a fresh local network: start it, deploy the canisters
+# of icp.yaml, run vitest, and stop the network again, also when a step fails.
+#
+# Needs `pnpm install` and `pnpm build` at the repository root first (the
+# suite imports the built packages), and Rust with the wasm32-unknown-unknown
+# target for the canister build.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+# The icp-cli and ic-wasm this package pins come first on PATH, in CI as
+# locally; a global install of the same version is only a fallback. Any other
+# version does not work: the network launcher and the project format in
+# icp.yaml are 1.2.0's.
+export PATH="$PWD/node_modules/.bin:$PATH"
+expected="$(node -p 'require("./package.json").devDependencies["@icp-sdk/icp-cli"]')"
+actual="$(icp --version | awk '{ print $2 }')"
+if [ "$actual" != "$expected" ]; then
+  echo "e2e needs icp-cli $expected, but \`icp\` on PATH is ${actual:-missing}. Run \`pnpm install\` at the repository root." >&2
+  exit 1
+fi
+echo "icp $actual, $(ic-wasm --version)"
+
+echo "===========CHECKING DECLARATIONS========="
+# src/declarations is what `meant gen` writes from the .did.
+pnpm gen:check
+
+stop_network() {
+  echo "===========STOPPING NETWORK========="
+  icp network stop || true
+}
+trap stop_network EXIT
+
+echo "===========SETUP========="
+icp network start -d
+icp deploy
+echo "===========SETUP DONE========="
+
+echo "===========VERIFYING DEPLOYMENT========="
+icp canister call hello_actor greet '("World")'
+echo "===========VERIFICATION DONE========="
+
+echo "===========TESTING========="
+pnpm exec vitest run
+echo "===========TESTING DONE========="
+
+echo "DONE"

package/e2e/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/e2e/tsconfig.typecheck.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*", "setup.ts", "global-setup.ts", "vitest.config.ts"],
+  "exclude": ["node_modules", "dist", "target"]
+}

package/e2e/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+  test: {
+    // A browser page by default: `auth` sign-in, the `ic_env` cookie and
+    // ReactorProvider exist only there. The agent still sends with Node's
+    // fetch, which jsdom does not replace, so nothing is blocked by CORS.
+    environment: "jsdom",
+    // Asks `icp` for the replica and the deployed canister once, and fails the
+    // run when there is none (start one with `bash test.sh`).
+    globalSetup: ["./global-setup.ts"],
+    setupFiles: ["./setup.ts"],
+    include: ["src/**/*.test.{ts,tsx}"],
+    // One file at a time: they share the canister's counter, and the
+    // anonymous-write case reads it back to show that nothing was sent.
+    fileParallelism: false,
+    testTimeout: 60_000,
+    hookTimeout: 120_000,
+    // No `passWithNoTests`: a run that finds no test file fails, so the E2E
+    // job cannot go green with nothing in it again.
+  },
+})

package/eslint.config.mjs

@@ -0,0 +1,100 @@
+import js from "@eslint/js"
+import tseslint from "typescript-eslint"
+
+/**
+ * Lint scope: TypeScript under `packages/<pkg>/src` and `packages/<pkg>/tests` --
+ * the same scope `pnpm typecheck` already covers. `docs/`, `e2e/`, `examples/`
+ * and `scripts/` stay out of scope for now.
+ */
+const SOURCES = [
+  "packages/*/src/**/*.{ts,tsx}",
+  "packages/*/tests/**/*.{ts,tsx}",
+]
+
+/**
+ * Type-aware rules need a tsconfig that actually contains the file, and
+ * `tsconfig.typecheck.json` is the only project in each package that includes
+ * both `src` and `tests`.
+ *
+ * The list is spelled out rather than globbed so that a package added without a
+ * `tsconfig.typecheck.json` fails loudly here instead of silently opting itself
+ * out of the type-aware rules -- which is the same silent-skip failure mode that
+ * left `packages/parser` unchecked by `pnpm typecheck` (issue #340).
+ */
+const TYPECHECK_PROJECTS = [
+  "packages/core/tsconfig.typecheck.json",
+  "packages/mcp/tsconfig.typecheck.json",
+  "packages/react/tsconfig.typecheck.json",
+  "packages/vite-plugin/tsconfig.typecheck.json",
+]
+
+export default tseslint.config(
+  {
+    ignores: [
+      "**/dist/**",
+      "**/node_modules/**",
+      "**/target/**",
+      "**/coverage/**",
+    ],
+  },
+  {
+    files: SOURCES,
+    extends: [js.configs.recommended, tseslint.configs.recommended],
+    // A directive that no longer suppresses anything is an error, so the stale
+    // `eslint-disable` comments this repo accumulated while no linter ran cannot
+    // come back (issue #341).
+    linterOptions: { reportUnusedDisableDirectives: "error" },
+    rules: {
+      // 425 hits, measured. Candid service types are structurally `any` at the
+      // actor boundary; turning this on is its own project, not a lint rollout.
+      "@typescript-eslint/no-explicit-any": "off",
+      // The rule's only fix is `new Error(msg, { cause })`, which needs lib
+      // ES2022; the packages compile against lib ES2020 (tsconfig.base.json), so
+      // the fix does not type-check here (TS2554).
+      "preserve-caught-error": "off",
+      // `{}` is the neutral branch of the Candid visitors' conditional types,
+      // never a value type.
+      "@typescript-eslint/no-empty-object-type": [
+        "error",
+        { allowObjectTypes: "always" },
+      ],
+      // The codebase already marks intentionally-unused bindings with `_`.
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+  {
+    files: SOURCES,
+    languageOptions: {
+      parserOptions: {
+        project: TYPECHECK_PROJECTS,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-misused-promises": "error",
+    },
+  },
+  {
+    // Tests reach for `require()` to re-import SDK modules inside assertions.
+    files: [
+      "packages/*/tests/**/*.{ts,tsx}",
+      "packages/*/src/**/*.test.{ts,tsx}",
+    ],
+    rules: { "@typescript-eslint/no-require-imports": "off" },
+  },
+  {
+    // Type-level tests call promise-returning hooks purely to assert their
+    // signatures; nothing awaits them by design.
+    files: ["**/*.test-d.ts"],
+    rules: { "@typescript-eslint/no-floating-promises": "off" },
+  }
+)