@cursor/july 0.1.26 → 0.1.28

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

@@ -1,213 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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 () => {},
-      },
-    },
-    artifacts: {
-      tag: async () => {
-        throw new Error("artifacts not configured in test");
-      },
-      list: 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

@@ -1,82 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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);
-  });
-});