test(integration-tests): add Emulate.dev-backed tests for the GitHub adapter (#479)

## Summary

Add an Emulate.dev-backed integration-test suite for the GitHub adapter,
mirroring the structure of the Slack work in #477. Tests drive the
adapter against an in-process
[`@emulators/github`](https://emulate.dev/docs/github) server and assert
on its stateful store (comments, reviews) rather than `mock.calls`,
catching wire-format and contract issues that pure Octokit mocks miss.

- New private devDeps in `packages/integration-tests`:
`@emulators/github`, `@emulators/core`, `@hono/node-server`, plus a
workspace dep on `@chat-adapter/github`. (`@emulators/core` and
`@hono/node-server` are also declared by #477; this PR is independent of
merge order.)
- New harness `packages/integration-tests/src/github-emulator-utils.ts`
boots the emulator on an ephemeral `127.0.0.1` port, seeds a
deterministic user / repo / issue / PR / starter review comment, and
exposes a near-passthrough HTTP forwarder. **No re-signing needed**
here. `@emulators/core`'s `WebhookDispatcher` already signs deliveries
with `X-Hub-Signature-256: sha256=<hex>` exactly as the GitHub adapter
expects. The harness also adds a small URL rewriter for Octokit's
`pulls.createReplyForReviewComment` shortcut endpoint, translating it
into the canonical review-comment POST that the emulator implements.
- Four new test files (12 tests), wired to the adapter via its existing
`apiUrl` + `webhookSecret` config **zero source changes** to
`packages/adapter-github`:
- `emulator-github-auth.test.ts` (2) `GET /user` populates `botUserId`
during `initialize()`.
- `emulator-github-comments.test.ts` (4) `thread.post` / `edit` /
`delete` on issue and PR-conversation threads.
- `emulator-github-reviews.test.ts` (3) review-comment replies routed
through `pulls.createReplyForReviewComment` with the right
\`in_reply_to_id\`, plus edit / delete.
- `emulator-github-events.test.ts` (3) full inbound `issue_comment` /
`pull_request_review_comment` round-trip, including bot self-message
filtering.

```mermaid
flowchart LR
  subgraph Test["Vitest test process"]
    SDK[GitHubAdapter + Chat]
    Forwarder["HTTP forwarder<br/>passthrough"]
    Emu["@emulators/github<br/>(in-process Hono)"]
  end

  SDK -->|"issues.createComment / pulls.* / GET /user<br/>(apiUrl override)"| Emu
  Emu -->|"X-Hub-Signature-256 + x-github-event"| Forwarder
  Forwarder -->|"chat.webhooks.github(request)"| SDK
```

### Out of scope (deliberate)

- **Reactions** `@emulators/github` does not implement the `/reactions`
endpoints used by the adapter. Reaction logic is still covered by the
existing mock-based tests in
`packages/adapter-github/src/index.test.ts`.
- **GitHub App auth** (JWT \u2192 installation token via `POST
/app/installations/:id/access_tokens`) the adapter and emulator both
support it, but PAT-mode was the agreed scope here.
- **Multi-tenant install flows** via `installation` webhook events.
- Branches/refs, releases, search, actions, checks not used by the
adapter.

## Test plan

- [x] `pnpm --filter @chat-adapter/integration-tests test` 407 tests
pass across 34 files (including the 12 new emulator-github tests, ~480
ms total).
- [x] `pnpm check` and `pnpm knip` clean.
- [x] CI safety verified: ephemeral ports (`port: 0`), loopback-only
binds (`127.0.0.1`), deterministic teardown via `httpServer.close()`, no
env vars, no external network egress.

## Checklist

- [x] All commits are signed and verified
- [x] \`pnpm validate\` passes
- [x] Changeset added (or N/A see [CONTRIBUTING.md](./CONTRIBUTING.md))
N/A: \`@chat-adapter/integration-tests\` is \`private: true\` and the
change is test-only.
- [x] Documentation updated (or N/A)
\`packages/integration-tests/README.md\` describes the new
emulator-github test category.

---------

Co-authored-by: Ben Sabic <bensabic@users.noreply.github.com>

Author: bensabic

packages/integration-tests/README.md

@@ -6,7 +6,7 @@ Integration tests for the Chat SDK that verify real-world webhook payloads are h
 
 - **Unit tests** (`slack.test.ts`, `teams.test.ts`, `gchat.test.ts`) - Test adapter functionality with mock payloads
 - **Replay tests** (`replay*.test.ts`) - Replay actual production webhook recordings
-- **Emulator tests** (`emulator-*.test.ts`) - Drive the SlackAdapter against an in-process [`@emulators/slack`](https://emulate.dev/docs/slack) server. Assertions read the emulator's stateful store (messages, reactions, installations) instead of mock call records. The emulator is wired in via the adapter's `apiUrl` config, and inbound `event_callback` deliveries are re-signed by a small in-test forwarder before being handed to `chat.webhooks.slack(...)`. Helpers live in [`src/slack-emulator-utils.ts`](./src/slack-emulator-utils.ts).
+- **Emulator tests** (`src/emulator/<adapter>/*.test.ts`) - Drive the SDK against an in-process Emulate.dev server, one per supported adapter ([`@emulators/slack`](https://emulate.dev/docs/slack), [`@emulators/github`](https://emulate.dev/docs/github)). Assertions read the emulator's stateful store (messages, comments, reactions, installations) instead of mock call records. Each adapter is wired in via its `apiUrl` config. Inbound deliveries: the Slack flow re-signs `event_callback` payloads with `x-slack-signature` via a small in-test forwarder before handing them to `chat.webhooks.slack(...)`, while the GitHub flow is a near-passthrough because the emulator's `WebhookDispatcher` already signs with `X-Hub-Signature-256` exactly as the adapter expects. Helpers live in [`src/emulator/slack/utils.ts`](./src/emulator/slack/utils.ts) and [`src/emulator/github/utils.ts`](./src/emulator/github/utils.ts).
 
 ## Replay Tests
 

packages/integration-tests/package.json

@@ -11,6 +11,7 @@
   },
   "devDependencies": {
     "@emulators/core": "^0.5.0",
+    "@emulators/github": "^0.5.0",
     "@emulators/slack": "^0.5.0",
     "@hono/node-server": "^2.0.2",
     "@types/node": "^25.3.2",
@@ -20,6 +21,7 @@
   "dependencies": {
     "@chat-adapter/discord": "workspace:*",
     "@chat-adapter/gchat": "workspace:*",
+    "@chat-adapter/github": "workspace:*",
     "@chat-adapter/messenger": "workspace:*",
     "@chat-adapter/slack": "workspace:*",
     "@chat-adapter/state-memory": "workspace:*",

packages/integration-tests/src/emulator/github/auth.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Asserts that the GitHubAdapter, when wired against the in-process GitHub
+ * emulator via `apiUrl`, auto-resolves its bot user id from
+ * `users.getAuthenticated` (i.e. `GET /user`) during `Chat.initialize()`.
+ * This proves the Octokit client correctly reaches the emulator and that the
+ * emulator's `GET /user` returns the seeded bot user.
+ */
+
+import { createGitHubAdapter, type GitHubAdapter } from "@chat-adapter/github";
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { Chat } from "chat";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import {
+  createGitHubEmulator,
+  type GitHubEmulatorHandle,
+  silentLogger,
+} from "./utils";
+
+describe("GitHub emulator: auth", () => {
+  let emulator: GitHubEmulatorHandle;
+  let chat: Chat<{ github: GitHubAdapter }> | undefined;
+
+  beforeAll(async () => {
+    emulator = await createGitHubEmulator();
+  });
+
+  afterEach(async () => {
+    if (chat) {
+      await chat.shutdown();
+      chat = undefined;
+    }
+    emulator.reset();
+  });
+
+  afterAll(async () => {
+    await emulator.close();
+  });
+
+  it("populates botUserId from GET /user during initialize()", async () => {
+    const adapter = createGitHubAdapter({
+      apiUrl: emulator.apiUrl,
+      token: emulator.botToken,
+      webhookSecret: emulator.webhookSecret,
+      userName: emulator.botLogin,
+      logger: silentLogger,
+    });
+    chat = new Chat({
+      userName: emulator.botLogin,
+      adapters: { github: adapter },
+      state: createMemoryState(),
+      logger: silentLogger,
+    });
+    await chat.initialize();
+
+    expect(adapter.botUserId).toBe(String(emulator.botUserId));
+  });
+
+  it("respects an explicit botUserId without calling GET /user", async () => {
+    const adapter = createGitHubAdapter({
+      apiUrl: emulator.apiUrl,
+      token: emulator.botToken,
+      webhookSecret: emulator.webhookSecret,
+      botUserId: 99_999,
+      userName: emulator.botLogin,
+      logger: silentLogger,
+    });
+    chat = new Chat({
+      userName: emulator.botLogin,
+      adapters: { github: adapter },
+      state: createMemoryState(),
+      logger: silentLogger,
+    });
+    await chat.initialize();
+
+    expect(adapter.botUserId).toBe("99999");
+  });
+});

packages/integration-tests/src/emulator/github/comments.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Verifies that outbound `thread.post` / `Message.edit` / `Message.delete` on
+ * GitHub issue and PR-level conversation threads round-trip through the
+ * adapter's Octokit client and land in the in-process emulator's stateful
+ * store.
+ *
+ * Drives the adapter via PAT-mode auth pointing at the emulator's `apiUrl`,
+ * obtains a Thread directly from `chat.thread(...)` (no inbound webhook
+ * needed), and asserts on the emulator's `comments` collection.
+ */
+
+import { createGitHubAdapter, type GitHubAdapter } from "@chat-adapter/github";
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { Chat } from "chat";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+} from "vitest";
+import {
+  createGitHubEmulator,
+  type GitHubEmulatorHandle,
+  silentLogger,
+} from "./utils";
+
+describe("GitHub emulator: issue/PR comment round-trip", () => {
+  let emulator: GitHubEmulatorHandle;
+  let chat: Chat<{ github: GitHubAdapter }>;
+  let adapter: GitHubAdapter;
+
+  beforeAll(async () => {
+    emulator = await createGitHubEmulator();
+  });
+
+  afterAll(async () => {
+    await emulator.close();
+  });
+
+  beforeEach(async () => {
+    adapter = createGitHubAdapter({
+      apiUrl: emulator.apiUrl,
+      token: emulator.botToken,
+      webhookSecret: emulator.webhookSecret,
+      userName: emulator.botLogin,
+      logger: silentLogger,
+    });
+    chat = new Chat({
+      userName: emulator.botLogin,
+      adapters: { github: adapter },
+      state: createMemoryState(),
+      logger: silentLogger,
+    });
+    await chat.initialize();
+  });
+
+  afterEach(async () => {
+    await chat.shutdown();
+    emulator.reset();
+  });
+
+  function botCommentsForRepo() {
+    return emulator.ghStore.comments
+      .all()
+      .filter((c) => c.user_id === emulator.botUserId);
+  }
+
+  it("posts an issue comment via issues.createComment", async () => {
+    const threadId = `github:${emulator.owner}/${emulator.repo}:issue:${emulator.issueNumber}`;
+    const thread = chat.thread(threadId);
+
+    await thread.post("Hello from the bot on the issue");
+
+    const comments = botCommentsForRepo();
+    expect(comments).toHaveLength(1);
+    expect(comments[0].body).toBe("Hello from the bot on the issue");
+    expect(comments[0].issue_number).toBe(emulator.issueNumber);
+    expect(comments[0].comment_type).toBe("issue");
+  });
+
+  it("posts a PR-level conversation comment via issues.createComment", async () => {
+    const threadId = `github:${emulator.owner}/${emulator.repo}:${emulator.prNumber}`;
+    const thread = chat.thread(threadId);
+
+    await thread.post("Hello from the bot on the PR");
+
+    const comments = botCommentsForRepo();
+    expect(comments).toHaveLength(1);
+    expect(comments[0].body).toBe("Hello from the bot on the PR");
+    expect(comments[0].issue_number).toBe(emulator.prNumber);
+    expect(comments[0].comment_type).toBe("issue");
+  });
+
+  it("editMessage updates the stored comment body via issues.updateComment", async () => {
+    const threadId = `github:${emulator.owner}/${emulator.repo}:${emulator.prNumber}`;
+    const thread = chat.thread(threadId);
+
+    const message = await thread.post("draft");
+    await message.edit("final");
+
+    const comments = botCommentsForRepo();
+    expect(comments).toHaveLength(1);
+    expect(comments[0].body).toBe("final");
+  });
+
+  it("deleteMessage removes the comment via issues.deleteComment", async () => {
+    const threadId = `github:${emulator.owner}/${emulator.repo}:${emulator.prNumber}`;
+    const thread = chat.thread(threadId);
+
+    const message = await thread.post("transient");
+    await message.delete();
+
+    expect(botCommentsForRepo()).toHaveLength(0);
+  });
+});