p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/tests/setup/vercel-setup-client.test.ts

@@ -0,0 +1,395 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+const fetchMock = vi.fn();
+
+vi.stubGlobal("fetch", fetchMock);
+
+import {
+  buildExistingEnvVarPatchBody,
+  createVercelTeam,
+  getDefaultEnvVarType,
+  isDeploymentSpecificVercelHost,
+  selectStableProductionHost,
+  upsertVercelProjectEnvVar,
+  VercelEnvVarTypeError,
+  VercelTeamBillingError,
+} from "../../src/setup/vercel-setup-client.js";
+
+describe("vercel-setup-client env var upsert", () => {
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("defaults secret env vars to sensitive on create", () => {
+    expect(getDefaultEnvVarType("LINEAR_WEBHOOK_SECRET")).toBe("sensitive");
+    expect(getDefaultEnvVarType("GITHUB_DISPATCH_TOKEN")).toBe("sensitive");
+    expect(getDefaultEnvVarType("HARNESS_TEAM_KEY")).toBe("plain");
+  });
+
+  it("builds existing env PATCH bodies without key or type", () => {
+    expect(
+      buildExistingEnvVarPatchBody({
+        value: "ghp_saved",
+        existingEnv: {
+          id: "env-1",
+          key: "GITHUB_DISPATCH_TOKEN",
+          type: "sensitive",
+          target: ["production"],
+        },
+      }),
+    ).toEqual({
+      value: "ghp_saved",
+      target: ["production"],
+    });
+  });
+
+  it("updates existing env vars without key or type in PATCH payload", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({}),
+    });
+
+    await upsertVercelProjectEnvVar("vercel-token", {
+      projectId: "proj-1",
+      key: "GITHUB_DISPATCH_TOKEN",
+      value: "ghp_saved",
+      existingEnv: {
+        id: "env-1",
+        key: "GITHUB_DISPATCH_TOKEN",
+        type: "sensitive",
+        target: ["production"],
+      },
+    });
+
+    const [, init] = fetchMock.mock.calls[0] ?? [];
+    expect(init?.method).toBe("PATCH");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      value: "ghp_saved",
+      target: ["production"],
+    });
+  });
+
+  it("creates env vars on the documented v10 endpoint", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 201,
+      json: async () => ({}),
+    });
+
+    await upsertVercelProjectEnvVar("vercel-token", {
+      projectId: "proj-1",
+      key: "HARNESS_TEAM_KEY",
+      value: "WES",
+    });
+
+    const [url, init] = fetchMock.mock.calls[0] ?? [];
+    expect(String(url)).toContain("/v10/projects/proj-1/env");
+    expect(init?.method).toBe("POST");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      key: "HARNESS_TEAM_KEY",
+      value: "WES",
+      type: "plain",
+      target: ["production"],
+    });
+  });
+
+  it("throws a targeted error when Vercel rejects sensitive type changes", async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 400,
+      text: async () =>
+        JSON.stringify({
+          error: {
+            code: "bad_request",
+            message:
+              "You cannot change the type of a sensitive environment variable.",
+          },
+        }),
+    });
+
+    await expect(
+      upsertVercelProjectEnvVar("vercel-token", {
+        projectId: "proj-1",
+        key: "GITHUB_DISPATCH_TOKEN",
+        value: "ghp_saved",
+        existingEnv: {
+          id: "env-1",
+          key: "GITHUB_DISPATCH_TOKEN",
+          type: "sensitive",
+          target: ["production"],
+        },
+      }),
+    ).rejects.toBeInstanceOf(VercelEnvVarTypeError);
+  });
+
+  it("throws a targeted error when Vercel rejects sensitive key changes", async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 400,
+      text: async () =>
+        JSON.stringify({
+          error: {
+            code: "BAD_REQUEST",
+            message:
+              "You cannot change the key of a Sensitive Environment Variable.",
+          },
+        }),
+    });
+
+    await expect(
+      upsertVercelProjectEnvVar("vercel-token", {
+        projectId: "proj-1",
+        key: "GITHUB_DISPATCH_TOKEN",
+        value: "ghp_saved",
+        existingEnv: {
+          id: "env-1",
+          key: "GITHUB_DISPATCH_TOKEN",
+          type: "sensitive",
+          target: ["production"],
+        },
+      }),
+    ).rejects.toMatchObject({
+      name: "VercelEnvVarTypeError",
+      key: "GITHUB_DISPATCH_TOKEN",
+    });
+  });
+
+  it("does not call DELETE when updating existing env vars", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({}),
+    });
+
+    await upsertVercelProjectEnvVar("vercel-token", {
+      projectId: "proj-1",
+      key: "GITHUB_DISPATCH_TOKEN",
+      value: "ghp_saved",
+      existingEnv: {
+        id: "env-1",
+        key: "GITHUB_DISPATCH_TOKEN",
+        type: "sensitive",
+        target: ["production"],
+      },
+    });
+
+    for (const [, init] of fetchMock.mock.calls) {
+      expect(String(init?.method ?? "GET")).not.toBe("DELETE");
+    }
+    expect(fetchMock.mock.calls.some(([, init]) => init?.method === "PATCH")).toBe(
+      true,
+    );
+  });
+});
+
+describe("canonical production URL resolution", () => {
+  it("detects deployment-specific vercel.app hosts", () => {
+    expect(
+      isDeploymentSpecificVercelHost(
+        "agentic-product-development-harness-apseun4qi-kinterra-team-url.vercel.app",
+      ),
+    ).toBe(true);
+    expect(isDeploymentSpecificVercelHost("harness-gui.vercel.app")).toBe(false);
+    expect(isDeploymentSpecificVercelHost("www.example.com")).toBe(false);
+  });
+
+  it("prefers stable production alias over deployment-specific READY URL", () => {
+    const selected = selectStableProductionHost({
+      deploymentUrl: "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+      aliases: [
+        "harness-gui.vercel.app",
+        "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+      ],
+    });
+
+    expect(selected.source).toBe("stable_alias");
+    expect(selected.host).toBe("harness-gui.vercel.app");
+  });
+
+  it("falls back to latest READY deployment URL when no stable alias exists", () => {
+    const selected = selectStableProductionHost({
+      deploymentUrl: "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+      aliases: [
+        "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+      ],
+    });
+
+    expect(selected.source).toBe("latest_ready_deployment");
+    expect(selected.host).toBe(
+      "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+    );
+  });
+
+  it("resolves canonical production target from deployment aliases", async () => {
+    fetchMock
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: async () => ({
+          deployments: [
+            {
+              uid: "dpl-ready",
+              url: "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+              state: "READY",
+              readyState: "READY",
+              alias: ["harness-gui.vercel.app"],
+            },
+          ],
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: async () => ({
+          uid: "dpl-ready",
+          url: "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+          state: "READY",
+          readyState: "READY",
+          alias: ["harness-gui.vercel.app"],
+        }),
+      });
+
+    const { resolveCanonicalProductionTarget } = await import(
+      "../../src/setup/vercel-setup-client.js"
+    );
+    const target = await resolveCanonicalProductionTarget({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      teamId: "team-1",
+    });
+
+    expect(target?.source).toBe("stable_alias");
+    expect(target?.productionUrl).toBe("https://harness-gui.vercel.app");
+    expect(target?.webhookUrl).toBe(
+      "https://harness-gui.vercel.app/api/linear-webhook",
+    );
+    expect(target?.deploymentUrl).toBe(
+      "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+    );
+  });
+});
+
+describe("vercel production redeploy client", () => {
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("lists production deployments with state filter", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        deployments: [
+          {
+            uid: "dpl-ready",
+            url: "harness-gui.vercel.app",
+            state: "READY",
+            readyState: "READY",
+          },
+        ],
+      }),
+    });
+
+    const { listVercelProductionDeployments } = await import(
+      "../../src/setup/vercel-setup-client.js"
+    );
+    const deployments = await listVercelProductionDeployments(
+      "vercel-token",
+      "proj-1",
+      "team-1",
+      { state: "READY", limit: 3 },
+    );
+
+    const [url] = fetchMock.mock.calls[0] ?? [];
+    expect(String(url)).toContain("projectId=proj-1");
+    expect(String(url)).toContain("target=production");
+    expect(String(url)).toContain("state=READY");
+    expect(String(url)).toContain("teamId=team-1");
+    expect(deployments[0]?.id).toBe("dpl-ready");
+  });
+
+  it("triggers production redeploy from an existing deployment id", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        uid: "dpl-new",
+        url: "harness-gui-new.vercel.app",
+        state: "BUILDING",
+        readyState: "BUILDING",
+      }),
+    });
+
+    const { triggerVercelProductionRedeploy } = await import(
+      "../../src/setup/vercel-setup-client.js"
+    );
+    const deployment = await triggerVercelProductionRedeploy("vercel-token", {
+      projectName: "harness-gui",
+      sourceDeploymentId: "dpl-source",
+      teamId: "team-1",
+    });
+
+    const [url, init] = fetchMock.mock.calls[0] ?? [];
+    expect(String(url)).toContain("/v13/deployments");
+    expect(init?.method).toBe("POST");
+    expect(JSON.parse(String(init?.body))).toEqual({
+      name: "harness-gui",
+      deploymentId: "dpl-source",
+      target: "production",
+    });
+    expect(deployment.id).toBe("dpl-new");
+  });
+
+  it("fetches deployment status for polling", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        uid: "dpl-new",
+        url: "harness-gui-new.vercel.app",
+        state: "READY",
+        readyState: "READY",
+      }),
+    });
+
+    const { getVercelDeployment } = await import(
+      "../../src/setup/vercel-setup-client.js"
+    );
+    const deployment = await getVercelDeployment(
+      "vercel-token",
+      "dpl-new",
+      "team-1",
+    );
+
+    const [url] = fetchMock.mock.calls[0] ?? [];
+    expect(String(url)).toContain("/v13/deployments/dpl-new");
+    expect(String(url)).toContain("teamId=team-1");
+    expect(deployment.readyState).toBe("READY");
+  });
+});
+
+describe("createVercelTeam provider errors", () => {
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("maps payment_method_required to a clear provider billing error", async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 400,
+      text: async () =>
+        JSON.stringify({
+          error: {
+            code: "payment_method_required",
+            message:
+              "A payment method is required to create a team, please try creating a team again with a new payment method.",
+          },
+        }),
+    });
+
+    await expect(
+      createVercelTeam("vercel-token", { slug: "new-team" }),
+    ).rejects.toBeInstanceOf(VercelTeamBillingError);
+  });
+});

package/workspace-snapshot/files/tests/setup/vercel-setup-plan.test.ts

@@ -0,0 +1,261 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+vi.mock("../../src/setup/vercel-setup-client.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../src/setup/vercel-setup-client.js")>();
+  return {
+    ...actual,
+    buildWebhookUrl: vi.fn((url: string) => `https://${url}/api/linear-webhook`),
+    checkWebhookEndpointReachable: vi.fn(),
+    resolveCanonicalProductionTarget: vi.fn(),
+    listVercelProjectEnvVars: vi.fn(),
+    listVercelProjects: vi.fn(),
+    listVercelTeams: vi.fn(),
+    summarizeRequiredEnvPresence: vi.fn(),
+  };
+});
+
+vi.mock("../../src/setup/linear-setup-plan.js", () => ({
+  summarizeLinearWebhookReadiness: vi.fn(),
+}));
+
+vi.mock("../../src/setup/linear-webhook-secret.js", () => ({
+  planLinearWebhookSecret: vi.fn(),
+}));
+
+import { summarizeLinearWebhookReadiness } from "../../src/setup/linear-setup-plan.js";
+import { planLinearWebhookSecret } from "../../src/setup/linear-webhook-secret.js";
+import {
+  resolveCanonicalProductionTarget,
+  listVercelProjectEnvVars,
+  listVercelProjects,
+  listVercelTeams,
+  summarizeRequiredEnvPresence,
+  checkWebhookEndpointReachable,
+} from "../../src/setup/vercel-setup-client.js";
+import {
+  previewVercelBridgeSetup,
+  resolveVercelBridgeEnvValue,
+} from "../../src/setup/vercel-setup-plan.js";
+
+describe("vercel-setup-plan", () => {
+  beforeEach(() => {
+    vi.mocked(listVercelTeams).mockResolvedValue([]);
+    vi.mocked(listVercelProjects).mockResolvedValue([
+      { id: "proj-1", name: "harness-gui", accountId: "acct-1" },
+    ]);
+    vi.mocked(resolveCanonicalProductionTarget).mockResolvedValue({
+      productionUrl: "https://harness-gui.vercel.app",
+      webhookUrl: "https://harness-gui.vercel.app/api/linear-webhook",
+      deploymentId: "dep-1",
+      deploymentUrl: "harness-gui.vercel.app",
+      source: "stable_alias",
+      stableAlias: "harness-gui.vercel.app",
+      readyState: "READY",
+      state: "READY",
+    });
+    vi.mocked(checkWebhookEndpointReachable).mockResolvedValue({
+      reachable: true,
+      statusCode: 405,
+    });
+    vi.mocked(listVercelProjectEnvVars).mockResolvedValue([]);
+    vi.mocked(summarizeRequiredEnvPresence).mockReturnValue({
+      LINEAR_WEBHOOK_SECRET: "missing",
+      GITHUB_DISPATCH_TOKEN: "missing",
+      HARNESS_TEAM_KEY: "missing",
+    });
+    vi.mocked(summarizeLinearWebhookReadiness).mockResolvedValue({
+      matchingWebhook: undefined,
+      manualSteps: [],
+    });
+    vi.mocked(planLinearWebhookSecret).mockResolvedValue({
+      mode: "automated",
+      secret: "generated-secret",
+      manualSteps: [],
+    });
+  });
+
+  it("resolves derived and generated env values without operator input", () => {
+    expect(
+      resolveVercelBridgeEnvValue({
+        key: "HARNESS_TEAM_KEY",
+        derivedHarnessTeamKey: "WES",
+      }),
+    ).toBe("WES");
+    expect(
+      resolveVercelBridgeEnvValue({
+        key: "GITHUB_DISPATCH_TOKEN",
+        derivedGithubDispatchToken: "ghp_saved",
+      }),
+    ).toBe("ghp_saved");
+    expect(
+      resolveVercelBridgeEnvValue({
+        key: "LINEAR_WEBHOOK_SECRET",
+        generatedLinearWebhookSecret: "generated-secret",
+      }),
+    ).toBe("generated-secret");
+  });
+
+  it("plans derived harness team key and generated webhook secret in preview", async () => {
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      derivedHarnessTeamKey: "WES",
+      derivedGithubDispatchToken: "ghp_saved",
+      willGenerateLinearWebhookSecret: true,
+      linearApiKey: "lin_api_test",
+    });
+
+    expect(preview.validationError).toBeUndefined();
+    expect(preview.githubDispatchSource).toBe("saved-github-token");
+    expect(preview.linearWebhookSecretMode).toBe("automated");
+    expect(preview.envWritePlan).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: "HARNESS_TEAM_KEY",
+          source: "derived",
+          action: "create",
+          desiredType: "plain",
+        }),
+        expect.objectContaining({
+          key: "GITHUB_DISPATCH_TOKEN",
+          source: "derived",
+          action: "create",
+          desiredType: "sensitive",
+        }),
+        expect.objectContaining({
+          key: "LINEAR_WEBHOOK_SECRET",
+          source: "generated",
+          action: "create",
+          desiredType: "sensitive",
+        }),
+      ]),
+    );
+    expect(JSON.stringify(preview)).not.toContain("ghp_saved");
+    expect(JSON.stringify(preview)).not.toContain("generated-secret");
+  });
+
+  it("validates create-new project mode without failing preview", async () => {
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      team: { mode: "existing", teamId: "" },
+      project: { mode: "create", projectName: "harness-configure-step3-test" },
+      derivedHarnessTeamKey: "WES",
+      derivedGithubDispatchToken: "ghp_saved",
+      willGenerateLinearWebhookSecret: true,
+    });
+
+    expect(preview.validationError).toBeUndefined();
+    expect(preview.selectedProject).toBeUndefined();
+    expect(preview.deploymentStatus).toBe("project-will-be-created");
+    expect(preview.manualSteps.join(" ")).toMatch(/will be created during apply/i);
+  });
+
+  it("reports missing deployment for existing projects without production URL", async () => {
+    vi.mocked(resolveCanonicalProductionTarget).mockResolvedValue(undefined);
+
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      derivedHarnessTeamKey: "WES",
+      derivedGithubDispatchToken: "ghp_saved",
+    });
+
+    expect(preview.deploymentStatus).toBe("missing");
+    expect(preview.deploymentRequired?.message).toMatch(/no production deployment/i);
+    expect(preview.webhookUrl).toBeUndefined();
+  });
+
+  it("plans generated webhook secret as update when Vercel already has LINEAR_WEBHOOK_SECRET", async () => {
+    vi.mocked(listVercelProjectEnvVars).mockResolvedValue([
+      {
+        id: "env-linear",
+        key: "LINEAR_WEBHOOK_SECRET",
+        type: "sensitive",
+        target: ["production"],
+      },
+    ]);
+
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      derivedHarnessTeamKey: "WES",
+      derivedGithubDispatchToken: "ghp_saved",
+      willGenerateLinearWebhookSecret: true,
+      linearApiKey: "lin_api_test",
+    });
+
+    expect(preview.envWritePlan).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: "LINEAR_WEBHOOK_SECRET",
+          action: "update",
+          source: "generated",
+        }),
+      ]),
+    );
+    expect(preview.linearWebhookVerified).toBe(false);
+    expect(preview.signedProbeVerified).toBe(false);
+  });
+
+  it("does not treat existing-unverified webhook mode as verified", async () => {
+    vi.mocked(summarizeLinearWebhookReadiness).mockResolvedValue({
+      matchingWebhook: {
+        id: "wh-1",
+        url: "https://harness-gui.vercel.app/api/linear-webhook",
+        enabled: true,
+        resourceTypes: ["Issue"],
+      },
+      manualSteps: [],
+    });
+    vi.mocked(planLinearWebhookSecret).mockResolvedValue({
+      mode: "existing-unverified",
+      manualSteps: ["Signing secret cannot be recovered."],
+    });
+
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      linearApiKey: "lin_api_test",
+      derivedHarnessTeamKey: "WES",
+    });
+
+    expect(preview.linearWebhookSecretMode).toBe("existing-unverified");
+    expect(preview.linearWebhookVerified).toBe(false);
+  });
+
+  it("prefers stable production alias when both alias and deployment-specific URL are available", async () => {
+    vi.mocked(resolveCanonicalProductionTarget).mockResolvedValue({
+      productionUrl: "https://harness-gui.vercel.app",
+      webhookUrl: "https://harness-gui.vercel.app/api/linear-webhook",
+      deploymentId: "dpl-new",
+      deploymentUrl:
+        "agentic-product-development-harness-da4vir36l-kinterra-team-url.vercel.app",
+      source: "stable_alias",
+      stableAlias: "harness-gui.vercel.app",
+      readyState: "READY",
+      state: "READY",
+    });
+
+    const preview = await previewVercelBridgeSetup({
+      vercelToken: "vercel-token",
+      projectId: "proj-1",
+      preferredProductionDeploymentId: "dpl-new",
+      derivedHarnessTeamKey: "WES",
+      derivedGithubDispatchToken: "ghp_saved",
+      linearApiKey: "lin_api_test",
+    });
+
+    expect(resolveCanonicalProductionTarget).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "proj-1",
+        preferredDeploymentId: "dpl-new",
+      }),
+    );
+    expect(preview.productionUrl).toBe("https://harness-gui.vercel.app");
+    expect(preview.webhookUrl).toBe(
+      "https://harness-gui.vercel.app/api/linear-webhook",
+    );
+    expect(preview.productionUrlSource).toBe("stable_alias");
+  });
+});