@cursor/july 0.1.20 → 0.1.21

package/src/internal/github-fanout.test.ts

@@ -0,0 +1,213 @@
+import { createHmac } from "node:crypto";
+import { createServer, type IncomingMessage, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { afterEach, describe, expect, it } from "vitest";
+import type { GitHubForwardTarget } from "../channels/github/forward.js";
+import { fanoutDelivery, startFanoutServer } from "./github-fanout.js";
+
+interface Captured {
+  method: string;
+  headers: IncomingMessage["headers"];
+  body: string;
+}
+
+/** A stand-in GitHub channel that records the requests it receives. */
+function recordingServer(): Promise<{
+  url: string;
+  received: Captured[];
+  close: () => void;
+}> {
+  const received: Captured[] = [];
+  const server: Server = createServer((req, res) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", () => {
+      received.push({
+        method: req.method ?? "",
+        headers: req.headers,
+        body: Buffer.concat(chunks).toString("utf8"),
+      });
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+    });
+  });
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address() as AddressInfo;
+      resolve({
+        url: `http://127.0.0.1:${port}`,
+        received,
+        close: () => server.close(),
+      });
+    });
+  });
+}
+
+const cleanups: Array<() => void> = [];
+afterEach(() => {
+  for (const cleanup of cleanups.splice(0)) {
+    cleanup();
+  }
+});
+
+describe("fanoutDelivery", () => {
+  it("re-posts the raw body + signature to every matching channel", async () => {
+    const a = await recordingServer();
+    const b = await recordingServer();
+    cleanups.push(a.close, b.close);
+
+    const targets: GitHubForwardTarget[] = [
+      {
+        slug: "fsd",
+        channelId: "github",
+        url: a.url,
+        events: ["pull_request"],
+      },
+      {
+        slug: "reviewer",
+        channelId: "github",
+        url: b.url,
+        events: ["pull_request"],
+      },
+    ];
+
+    const body = Buffer.from(JSON.stringify({ action: "opened" }));
+    const signature = `sha256=${createHmac("sha256", "s3cr3t").update(body).digest("hex")}`;
+    const delivered = await fanoutDelivery(
+      body,
+      {
+        "content-type": "application/json",
+        "x-github-event": "pull_request",
+        "x-hub-signature-256": signature,
+      },
+      targets,
+      { logger: () => {} }
+    );
+
+    expect(delivered.sort()).toEqual(["fsd/github", "reviewer/github"]);
+    for (const server of [a, b]) {
+      expect(server.received).toHaveLength(1);
+      expect(server.received[0]?.body).toBe(body.toString("utf8"));
+      expect(server.received[0]?.headers["x-hub-signature-256"]).toBe(
+        signature
+      );
+      expect(server.received[0]?.headers["x-github-event"]).toBe(
+        "pull_request"
+      );
+    }
+  });
+
+  it("delivers only to channels whose event set matches", async () => {
+    const fsd = await recordingServer();
+    const reviewer = await recordingServer();
+    cleanups.push(fsd.close, reviewer.close);
+
+    const targets: GitHubForwardTarget[] = [
+      {
+        slug: "fsd",
+        channelId: "github",
+        url: fsd.url,
+        events: ["pull_request", "check_run"],
+      },
+      {
+        slug: "reviewer",
+        channelId: "github",
+        url: reviewer.url,
+        events: ["pull_request"],
+      },
+    ];
+
+    const delivered = await fanoutDelivery(
+      Buffer.from("{}"),
+      { "x-github-event": "check_run" },
+      targets,
+      { logger: () => {} }
+    );
+
+    expect(delivered).toEqual(["fsd/github"]);
+    expect(fsd.received).toHaveLength(1);
+    expect(reviewer.received).toHaveLength(0);
+  });
+
+  it("does not count HTTP error responses as delivered", async () => {
+    const ok = await recordingServer();
+    const failing = createServer((req, res) => {
+      const chunks: Buffer[] = [];
+      req.on("data", (chunk: Buffer) => chunks.push(chunk));
+      req.on("end", () => {
+        res.writeHead(500);
+        res.end("error");
+      });
+    });
+    await new Promise<void>((resolve) => {
+      failing.listen(0, "127.0.0.1", () => resolve());
+    });
+    const failingPort = (failing.address() as AddressInfo).port;
+    cleanups.push(ok.close, () => failing.close());
+
+    const targets: GitHubForwardTarget[] = [
+      {
+        slug: "ok",
+        channelId: "github",
+        url: ok.url,
+        events: ["pull_request"],
+      },
+      {
+        slug: "bad",
+        channelId: "github",
+        url: `http://127.0.0.1:${failingPort}`,
+        events: ["pull_request"],
+      },
+    ];
+
+    const delivered = await fanoutDelivery(
+      Buffer.from("{}"),
+      { "x-github-event": "pull_request" },
+      targets,
+      { logger: () => {} }
+    );
+
+    expect(delivered).toEqual(["ok/github"]);
+    expect(ok.received).toHaveLength(1);
+  });
+});
+
+describe("startFanoutServer", () => {
+  it("proxies a POST through to matching channels", async () => {
+    const channel = await recordingServer();
+    cleanups.push(channel.close);
+
+    const proxy = await startFanoutServer(
+      [
+        {
+          slug: "fsd",
+          channelId: "github",
+          url: channel.url,
+          events: ["pull_request"],
+        },
+      ],
+      { logger: () => {} }
+    );
+    cleanups.push(proxy.close);
+
+    const response = await fetch(proxy.url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-github-event": "pull_request",
+      },
+      body: JSON.stringify({ action: "synchronize" }),
+    });
+    const result = (await response.json()) as {
+      ok: boolean;
+      delivered: string[];
+    };
+
+    expect(response.status).toBe(200);
+    expect(result).toEqual({ ok: true, delivered: ["fsd/github"] });
+    expect(channel.received).toHaveLength(1);
+    expect(channel.received[0]?.body).toBe(
+      JSON.stringify({ action: "synchronize" })
+    );
+  });
+});

package/src/internal/handleAgentServeTrigger.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it, vi } from "vitest";
+import { githubChannel } from "../channels/github/github-channel.js";
+import type {
+  ChannelHandlerArgs,
+  ChannelSession,
+  SendMessageFn,
+} from "../types.js";
+import {
+  collectGitHubTriggerTargets,
+  handleAgentServeTrigger,
+} from "./handleAgentServeTrigger.js";
+
+describe("handleAgentServeTrigger", () => {
+  it("fans out a pull_request delivery to every github channel target", async () => {
+    const sendA = vi.fn<SendMessageFn>(async () => fakeSession("a"));
+    const sendB = vi.fn<SendMessageFn>(async () => fakeSession("b"));
+
+    const channelA = githubChannel({
+      auth: [],
+      onPullRequest: (ctx) => ({
+        auth: {
+          authenticator: "github-webhook",
+          principalId: ctx.senderLogin ?? "github",
+          principalType: "user",
+        },
+      }),
+    });
+    const channelB = githubChannel({
+      auth: [],
+      onPullRequest: () => null,
+    });
+    const buildSecurityReviewerArgs = vi.fn(() => handlerArgs(sendA));
+
+    const targets = collectGitHubTriggerTargets({
+      mounts: [
+        {
+          slug: "security-reviewer",
+          channels: [{ id: "reviewer", definition: channelA }],
+          buildHandlerArgs: buildSecurityReviewerArgs,
+        },
+        {
+          slug: "fsd",
+          channels: [{ id: "github", definition: channelB }],
+          buildHandlerArgs: () => handlerArgs(sendB),
+        },
+        {
+          slug: "weather-agent",
+          channels: [],
+          buildHandlerArgs: () => handlerArgs(vi.fn()),
+        },
+      ],
+    });
+
+    expect(targets.map((t) => t.slug)).toEqual(["security-reviewer", "fsd"]);
+    expect(buildSecurityReviewerArgs).toHaveBeenCalledWith("reviewer");
+
+    const result = await handleAgentServeTrigger({
+      type: "github",
+      bodyText: JSON.stringify(pullRequestPayload()),
+      eventName: "pull_request",
+      deliveryId: "delivery-1",
+      targets,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.targets).toHaveLength(2);
+    expect(result.targets[0]?.slug).toBe("security-reviewer");
+    expect(result.targets[0]?.status).toBe(200);
+    expect(result.targets[1]?.slug).toBe("fsd");
+    expect(result.targets[1]?.body).toMatchObject({
+      ok: true,
+      skipped: true,
+      reason: "not_dispatched",
+    });
+    expect(sendA).toHaveBeenCalledOnce();
+    expect(sendB).not.toHaveBeenCalled();
+  });
+
+  it("rejects invalid JSON without dispatching", async () => {
+    const result = await handleAgentServeTrigger({
+      type: "github",
+      bodyText: "not-json",
+      eventName: "pull_request",
+      targets: [],
+    });
+    expect(result.ok).toBe(false);
+    expect(result.targets[0]?.status).toBe(400);
+  });
+});
+
+function handlerArgs(send: SendMessageFn): ChannelHandlerArgs {
+  return {
+    params: {},
+    requestIp: "127.0.0.1",
+    auth: null,
+    host: {
+      mcp: {
+        names: () => [],
+        listTools: async () => [],
+        callTool: async () => ({ content: [] }),
+      },
+      github: {
+        getOctokit: async () => {
+          throw new Error("github client not configured in test");
+        },
+      },
+      slack: {
+        getClient: async () => {
+          throw new Error("slack client not configured in test");
+        },
+      },
+      kv: {
+        get: async () => undefined,
+        put: async () => {},
+        delete: async () => {},
+      },
+    },
+    send,
+    getSession: async () => null,
+    receive: async () => fakeSession("recv"),
+    callTool: async (toolName) => ({
+      toolName,
+      callId: "call-1",
+      isError: false,
+      result: null,
+      durationMs: 0,
+    }),
+    waitUntil: () => {},
+    sessionUrls: () => ({
+      playgroundUrl: "http://127.0.0.1:3000/playground",
+      traceUrl: "http://127.0.0.1:3000/v1/session/x/events",
+    }),
+  };
+}
+
+function fakeSession(id: string): ChannelSession {
+  return {
+    id,
+    isNew: true,
+    continuationToken: `github-pr:acme/widgets#42:${id}`,
+    info: {
+      id,
+      channelId: "github",
+      mode: "chat",
+      auth: null,
+      sdkAgentId: undefined,
+      title: "GitHub acme/widgets#42",
+    },
+    getEventStream: async () => new ReadableStream<Uint8Array>(),
+    waitForCompletion: async () => ({ status: "finished", result: "done" }),
+    setContinuationToken: async () => {},
+  };
+}
+
+function pullRequestPayload(): Record<string, unknown> {
+  return {
+    action: "opened",
+    repository: {
+      full_name: "acme/widgets",
+      html_url: "https://github.com/acme/widgets",
+    },
+    pull_request: {
+      number: 42,
+      html_url: "https://github.com/acme/widgets/pull/42",
+      title: "Add widgets",
+      body: "PR body",
+      draft: false,
+      user: { login: "octocat" },
+      head: {
+        ref: "feature/widgets",
+        sha: "abc123",
+      },
+      base: {
+        ref: "main",
+      },
+    },
+    sender: { login: "sender" },
+  };
+}

package/src/internal/host-kv.test.ts

@@ -0,0 +1,82 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { defineStorage, storageKeys } from "../storage.js";
+import { createHostKvApi } from "./host-kv.js";
+import { StorageCoordinator } from "./storage-coordinator.js";
+
+describe("createHostKvApi", () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      dirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true }))
+    );
+  });
+
+  async function tempDir(): Promise<string> {
+    const dir = await mkdtemp(join(tmpdir(), "agentkit-host-kv-"));
+    dirs.push(dir);
+    return dir;
+  }
+
+  it("falls back to state-root files when defineStorage is absent", async () => {
+    const stateRoot = await tempDir();
+    const kv = createHostKvApi({ agentName: "jenny", stateRoot });
+
+    expect(await kv.get("alert-memory/a")).toBeUndefined();
+    await kv.put("alert-memory/a", { class: "monitor:1", updated: "t" });
+    expect(await kv.get("alert-memory/a")).toEqual({
+      class: "monitor:1",
+      updated: "t",
+    });
+    await kv.delete("alert-memory/a");
+    expect(await kv.get("alert-memory/a")).toBeUndefined();
+  });
+
+  it("uses defineStorage under storageKeys.kv when get is present", async () => {
+    const stateRoot = await tempDir();
+    const store = new Map<string, unknown>();
+    const coordinator = new StorageCoordinator({
+      definition: defineStorage({
+        put: (key, value) => {
+          store.set(key, value);
+        },
+        get: (key) => store.get(key) as never,
+        delete: (key) => {
+          store.delete(key);
+        },
+        list: (prefix) =>
+          [...store.entries()]
+            .filter(([key]) => key.startsWith(prefix))
+            .map(([key, value]) => ({ key, value: value as never }))
+            .sort((a, b) => a.key.localeCompare(b.key)),
+      }),
+      agentName: "jenny",
+      projectRoot: stateRoot,
+      logger: () => {},
+    });
+    const kv = createHostKvApi({
+      agentName: "jenny",
+      stateRoot,
+      storage: coordinator,
+    });
+
+    await kv.put("alert-memory/x", { ok: true });
+    expect(store.get(storageKeys.kv("jenny", "alert-memory/x"))).toEqual({
+      ok: true,
+    });
+    expect(await kv.get("alert-memory/x")).toEqual({ ok: true });
+    await kv.delete("alert-memory/x");
+    expect(store.has(storageKeys.kv("jenny", "alert-memory/x"))).toBe(false);
+  });
+
+  it("rejects empty keys", async () => {
+    const kv = createHostKvApi({
+      agentName: "jenny",
+      stateRoot: await tempDir(),
+    });
+    await expect(kv.get("  ")).rejects.toThrow(/non-empty/);
+  });
+});

package/src/internal/host-platforms.test.ts

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const tryResolveGhAuthToken = vi.hoisted(() => vi.fn());
+const hasGitHubAppCredentials = vi.hoisted(() => vi.fn());
+const resolveGitHubInstallationId = vi.hoisted(() => vi.fn());
+const ensureGhCliTokenEnv = vi.hoisted(() => vi.fn());
+
+vi.mock("../channels/github/auth.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../channels/github/auth.js")>();
+  return {
+    ...actual,
+    tryResolveGhAuthToken,
+    hasGitHubAppCredentials,
+    resolveGitHubInstallationId,
+    ensureGhCliTokenEnv,
+  };
+});
+
+import { clearGitHubAuthCaches } from "../channels/github/auth.js";
+import {
+  resolveHostGitHubAuthSource,
+  warmupHostGitHubAuth,
+} from "./host-platforms.js";
+
+describe("host GitHub auth warmup", () => {
+  beforeEach(() => {
+    clearGitHubAuthCaches();
+    tryResolveGhAuthToken.mockReset();
+    hasGitHubAppCredentials.mockReset();
+    resolveGitHubInstallationId.mockReset();
+    ensureGhCliTokenEnv.mockReset();
+    hasGitHubAppCredentials.mockResolvedValue(false);
+    resolveGitHubInstallationId.mockResolvedValue(undefined);
+    ensureGhCliTokenEnv.mockResolvedValue(false);
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+  });
+
+  afterEach(() => {
+    clearGitHubAuthCaches();
+    tryResolveGhAuthToken.mockReset();
+    hasGitHubAppCredentials.mockReset();
+    resolveGitHubInstallationId.mockReset();
+    ensureGhCliTokenEnv.mockReset();
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+  });
+
+  it("prefers App installation auth over env PAT", async () => {
+    process.env.GITHUB_TOKEN = "env-token";
+    hasGitHubAppCredentials.mockResolvedValue(true);
+    resolveGitHubInstallationId.mockResolvedValue(42);
+    await expect(resolveHostGitHubAuthSource()).resolves.toBe("app");
+    expect(tryResolveGhAuthToken).not.toHaveBeenCalled();
+  });
+
+  it("prefers env over gh when App creds are unset", async () => {
+    process.env.GITHUB_TOKEN = "env-token";
+    tryResolveGhAuthToken.mockResolvedValue("gh-token");
+    await expect(resolveHostGitHubAuthSource()).resolves.toBe("env");
+    expect(tryResolveGhAuthToken).not.toHaveBeenCalled();
+  });
+
+  it("falls back to gh auth token", async () => {
+    tryResolveGhAuthToken.mockResolvedValue("gh-token");
+    await expect(resolveHostGitHubAuthSource()).resolves.toBe("gh");
+    expect(tryResolveGhAuthToken).toHaveBeenCalledOnce();
+  });
+
+  it("reports unavailable when neither App, env, nor gh works", async () => {
+    tryResolveGhAuthToken.mockResolvedValue(undefined);
+    await expect(resolveHostGitHubAuthSource()).resolves.toBe("unavailable");
+  });
+
+  it("logs and primes Octokit on successful warmup", async () => {
+    process.env.GITHUB_TOKEN = "env-token";
+    const lines: string[] = [];
+    const getOctokit = vi.fn(async () => ({ ok: true }) as never);
+    await expect(
+      warmupHostGitHubAuth({
+        logger: (line) => lines.push(line),
+        github: { getOctokit },
+      })
+    ).resolves.toBe("env");
+    expect(getOctokit).toHaveBeenCalledOnce();
+    expect(lines.some((line) => line.includes("GITHUB_TOKEN/GH_TOKEN"))).toBe(
+      true
+    );
+  });
+
+  it("warns without failing when auth is unavailable", async () => {
+    tryResolveGhAuthToken.mockResolvedValue(undefined);
+    const lines: string[] = [];
+    const getOctokit = vi.fn(async () => {
+      throw new Error("should not be called");
+    });
+    await expect(
+      warmupHostGitHubAuth({
+        logger: (line) => lines.push(line),
+        github: { getOctokit },
+      })
+    ).resolves.toBe("unavailable");
+    expect(getOctokit).not.toHaveBeenCalled();
+    expect(ensureGhCliTokenEnv).not.toHaveBeenCalled();
+    expect(lines.some((line) => line.includes("unavailable"))).toBe(true);
+  });
+
+  it("exports GH_TOKEN for gh CLI when App auth is configured", async () => {
+    hasGitHubAppCredentials.mockResolvedValue(true);
+    resolveGitHubInstallationId.mockResolvedValue(42);
+    ensureGhCliTokenEnv.mockResolvedValue(true);
+    const lines: string[] = [];
+    const getOctokit = vi.fn(async () => ({ ok: true }) as never);
+    await expect(
+      warmupHostGitHubAuth({
+        logger: (line) => lines.push(line),
+        github: { getOctokit },
+      })
+    ).resolves.toBe("app");
+    expect(ensureGhCliTokenEnv).toHaveBeenCalledOnce();
+    expect(
+      lines.some((line) => line.includes("exported as GH_TOKEN for gh CLI"))
+    ).toBe(true);
+  });
+});