p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/tests/setup/config-builder.test.ts

@@ -0,0 +1,136 @@
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { harnessConfigSchema } from "../../src/config/schema.js";
+import {
+  buildExampleTargetAppConfig,
+  buildHarnessConfigJson,
+} from "../../src/setup/config-builder.js";
+import { writeConfigLocal } from "../../src/setup/config-writer.js";
+import { resolveLocalFilePaths } from "../../src/setup/setup-state.js";
+
+describe("config-builder", () => {
+  it("builds config with generic target repo placeholders", () => {
+    const config = buildExampleTargetAppConfig();
+
+    expect(config.repos[0]?.id).toBe("target-app");
+    expect(config.repos[0]?.targetRepo).toBe(
+      "https://github.com/owner/example-target-app",
+    );
+    expect(config.repos[0]?.linearProjects).toEqual(["Example Target App"]);
+    expect(config.agentProvider?.id).toBe("cursor");
+    expect(config.agentProvider?.model?.id).toBe("composer-2.5");
+    expect(config.defaultModel?.id).toBe("composer-2.5");
+    expect(harnessConfigSchema.safeParse(config).success).toBe(true);
+  });
+
+  it("formats stable JSON with trailing newline", () => {
+    const json = buildHarnessConfigJson({
+      repos: [
+        {
+          id: "target-app",
+          linearProjects: ["Example Target App"],
+          targetRepo: "https://github.com/owner/example-target-app",
+        },
+      ],
+    });
+
+    expect(json.endsWith("\n")).toBe(true);
+    expect(json).toContain('"id": "target-app"');
+  });
+});
+
+describe("writeConfigLocal", () => {
+  let tempRoot = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-config-writer-"));
+    const paths = resolveLocalFilePaths(tempRoot);
+    await mkdir(paths.harnessDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("dry-run does not write config.local.json", async () => {
+    const paths = resolveLocalFilePaths(tempRoot);
+    const result = await writeConfigLocal({
+      paths,
+      mode: "dry-run",
+      input: {
+        repos: [
+          {
+            id: "target-app",
+            linearProjects: ["Example Target App"],
+            targetRepo: "https://github.com/owner/example-target-app",
+          },
+        ],
+      },
+    });
+
+    expect(result.outcome).toBe("preview");
+    await expect(access(paths.configLocal)).rejects.toThrow();
+  });
+
+  it("apply writes only .harness/config.local.json", async () => {
+    const paths = resolveLocalFilePaths(tempRoot);
+    const result = await writeConfigLocal({
+      paths,
+      mode: "apply",
+      input: {
+        repos: [
+          {
+            id: "target-app",
+            linearProjects: ["Example Target App"],
+            targetRepo: "https://github.com/owner/example-target-app",
+          },
+        ],
+      },
+    });
+
+    expect(result.outcome).toBe("changed");
+    const configLocal = await readFile(paths.configLocal, "utf8");
+    expect(configLocal).toContain('"id": "target-app"');
+    await expect(access(paths.envLocal)).rejects.toThrow();
+  });
+
+  it("skips existing config unless force is set", async () => {
+    const paths = resolveLocalFilePaths(tempRoot);
+    await writeFile(paths.configLocal, "SENTINEL_CONFIG", "utf8");
+
+    const skipped = await writeConfigLocal({
+      paths,
+      mode: "apply",
+      input: {
+        repos: [
+          {
+            id: "target-app",
+            targetRepo: "https://github.com/owner/example-target-app",
+          },
+        ],
+      },
+    });
+
+    expect(skipped.outcome).toBe("skipped");
+    expect(await readFile(paths.configLocal, "utf8")).toBe("SENTINEL_CONFIG");
+
+    const forced = await writeConfigLocal({
+      paths,
+      force: true,
+      mode: "apply",
+      input: {
+        repos: [
+          {
+            id: "target-app",
+            targetRepo: "https://github.com/owner/example-target-app",
+          },
+        ],
+      },
+    });
+
+    expect(forced.outcome).toBe("changed");
+    expect(await readFile(paths.configLocal, "utf8")).toContain('"id": "target-app"');
+  });
+});

package/workspace-snapshot/files/tests/setup/config-local-editor.test.ts

@@ -0,0 +1,164 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  createEmptyConfigFormInput,
+  isExampleHarnessConfig,
+  isExampleTemplateValue,
+  loadConfigFormDefaults,
+  normalizeConfigFormInput,
+  validateConfigFormInput,
+} from "../../src/setup/config-local-editor.js";
+import {
+  deriveRepoConfigIdFromUrl,
+  prepareGuidedConfigFormInput,
+} from "../../src/setup/guided-config-form.js";
+import { buildExampleTargetAppConfig } from "../../src/setup/config-builder.js";
+
+describe("config-local-editor", () => {
+  it("normalizes comma-separated linear projects and newline commands", () => {
+    const normalized = normalizeConfigFormInput({
+      linearTeamKey: "WES",
+      modelId: "composer-2.5",
+      repos: [
+        {
+          id: "target-app",
+          targetRepo: "https://github.com/owner/example-target-app",
+          linearProjects: "App One, App Two",
+          linearTeams: "Team A\nTeam B",
+          validationCommands: "npm run lint\nnpm run build",
+        },
+      ],
+    });
+
+    expect(normalized.repos[0]?.linearProjects).toEqual(["App One", "App Two"]);
+    expect(normalized.repos[0]?.linearTeams).toEqual(["Team A", "Team B"]);
+    expect(normalized.repos[0]?.validationCommands).toEqual([
+      "npm run lint",
+      "npm run build",
+    ]);
+    expect(normalized.allowedTargetRepos).toBeUndefined();
+  });
+
+  it("generates allowedTargetRepos closure from repo mappings", () => {
+    const { config } = validateConfigFormInput({
+      repos: [
+        {
+          id: "target-app",
+          targetRepo: "https://github.com/owner/example-target-app",
+        },
+      ],
+    });
+
+    expect(config.allowedTargetRepos).toEqual([
+      "https://github.com/owner/example-target-app",
+    ]);
+  });
+
+  it("rejects invalid config before write", () => {
+    expect(() =>
+      validateConfigFormInput({
+        repos: [
+          {
+            id: "",
+            targetRepo: "not-a-valid-url",
+          },
+        ],
+      }),
+    ).toThrow();
+  });
+
+  it("requires at least one repo", () => {
+    expect(() =>
+      normalizeConfigFormInput({
+        repos: [],
+      }),
+    ).toThrow(/At least one target repo/);
+  });
+
+  it("returns empty first-run defaults when no operator config exists", async () => {
+    const tempRoot = await mkdtemp(path.join(tmpdir(), "harness-config-defaults-"));
+    try {
+      const defaults = await loadConfigFormDefaults({ cwd: tempRoot });
+      expect(defaults).toEqual(createEmptyConfigFormInput());
+      expect(JSON.stringify(defaults)).not.toContain("example-target-app");
+      expect(JSON.stringify(defaults)).not.toContain("target-app");
+      expect(JSON.stringify(defaults)).not.toContain("Example Target App");
+      expect(JSON.stringify(defaults)).not.toContain("staging.example.com");
+      expect(JSON.stringify(defaults)).not.toContain("example.com");
+      expect(defaults.linearTeamKey).toBeUndefined();
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("loads real operator config.local.json values into the form", async () => {
+    const tempRoot = await mkdtemp(path.join(tmpdir(), "harness-config-operator-"));
+    try {
+      const harnessDir = path.join(tempRoot, ".harness");
+      await mkdir(harnessDir, { recursive: true });
+      await writeFile(
+        path.join(tempRoot, ".env.local"),
+        "HARNESS_CONFIG_PATH=.harness/config.local.json\n",
+        "utf8",
+      );
+      await writeFile(
+        path.join(harnessDir, "config.local.json"),
+        JSON.stringify(
+          {
+            version: 1,
+            repos: [
+              {
+                id: "my-real-app",
+                targetRepo: "https://github.com/acme/my-real-app",
+              },
+            ],
+            allowedTargetRepos: ["https://github.com/acme/my-real-app"],
+          },
+          null,
+          2,
+        ),
+        "utf8",
+      );
+
+      const defaults = await loadConfigFormDefaults({ cwd: tempRoot });
+      expect(defaults.repos[0]?.id).toBe("my-real-app");
+      expect(defaults.repos[0]?.targetRepo).toBe(
+        "https://github.com/acme/my-real-app",
+      );
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("derives repo config id from target repo URL for guided mode", () => {
+    expect(
+      deriveRepoConfigIdFromUrl("https://github.com/acme/my-product"),
+    ).toBe("my-product");
+    expect(prepareGuidedConfigFormInput({
+      repos: [{ id: "", targetRepo: "https://github.com/acme/my-product" }],
+    }).repos[0]?.id).toBe("my-product");
+  });
+
+  it("builds valid config from minimal guided input", () => {
+    const { config } = validateConfigFormInput(
+      prepareGuidedConfigFormInput({
+        repos: [{ id: "", targetRepo: "https://github.com/acme/my-product" }],
+      }),
+    );
+
+    expect(config.repos[0]?.id).toBe("my-product");
+    expect(config.allowedTargetRepos).toEqual([
+      "https://github.com/acme/my-product",
+    ]);
+  });
+
+  it("detects example harness config values", () => {
+    expect(isExampleHarnessConfig(buildExampleTargetAppConfig())).toBe(true);
+    expect(isExampleTemplateValue("https://github.com/owner/example-target-app")).toBe(
+      true,
+    );
+    expect(isExampleTemplateValue("WES")).toBe(true);
+  });
+});

package/workspace-snapshot/files/tests/setup/connect-services-credential-availability.test.ts

@@ -0,0 +1,151 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  applyConnectServicesEnv,
+  previewConnectServicesEnv,
+} from "../../src/setup/local-apply-actions";
+import { loadSecretFromEnvLocal } from "../../src/setup/service-verification";
+import { buildVercelSetupSummary } from "../../src/setup/vercel-setup-summary";
+import { buildLinearSetupSummary } from "../../src/setup/linear-setup-summary";
+import { loadGithubTokenFromEnvLocal } from "../../src/setup/setup-github-auth";
+
+vi.mock("../../src/setup/vercel-setup-client.js", () => ({
+  listVercelTeams: vi.fn().mockResolvedValue([]),
+  listVercelProjects: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("../../src/setup/github-dispatch-token.js", () => ({
+  assessGitHubDispatchTokenEligibility: vi.fn().mockResolvedValue({
+    eligible: true,
+    source: "saved-github-token",
+    repository: "owner/harness",
+    message: "Saved GITHUB_TOKEN can dispatch to owner/harness.",
+  }),
+}));
+
+import { loadVercelBridgeOptions } from "../../src/setup/vercel-bridge-options.js";
+
+const FAKE_SECRETS = {
+  linearApiKey: "fake-linear-key-for-same-process-test",
+  cursorApiKey: "fake-cursor-key-for-same-process-test",
+  githubToken: "fake-github-token-for-same-process-test",
+  vercelToken: "fake-vercel-token-for-same-process-test",
+};
+
+describe("connect services credential availability in same process", () => {
+  let tempRoot = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(
+      path.join(tmpdir(), "harness-connect-services-availability-"),
+    );
+    await mkdir(path.join(tempRoot, ".harness"), { recursive: true });
+    await writeFile(
+      path.join(tempRoot, ".env.example"),
+      "HARNESS_CONFIG_PATH=.harness/config.local.json\n",
+      "utf8",
+    );
+    delete process.env.LINEAR_API_KEY;
+    delete process.env.CURSOR_API_KEY;
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.VERCEL_TOKEN;
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  async function applyAllConnectServiceKeys() {
+    const env = {
+      harnessConfigPath: ".harness/config.local.json",
+      linearApiKey: FAKE_SECRETS.linearApiKey,
+      cursorApiKey: FAKE_SECRETS.cursorApiKey,
+      githubToken: FAKE_SECRETS.githubToken,
+      vercelToken: FAKE_SECRETS.vercelToken,
+    };
+    const preview = await previewConnectServicesEnv({ cwd: tempRoot, env });
+    await applyConnectServicesEnv({
+      cwd: tempRoot,
+      env,
+      confirmed: true,
+      fingerprint: preview.fingerprint,
+    });
+  }
+
+  it("writes VERCEL_TOKEN to .env.local and reads it without restarting the process", async () => {
+    await applyAllConnectServiceKeys();
+
+    const vercelToken = await loadSecretFromEnvLocal({
+      cwd: tempRoot,
+      key: "VERCEL_TOKEN",
+    });
+
+    expect(vercelToken).toBe(FAKE_SECRETS.vercelToken);
+  });
+
+  it("loads Vercel bridge options from saved VERCEL_TOKEN in the same process", async () => {
+    await applyAllConnectServiceKeys();
+
+    const vercelToken =
+      (await loadSecretFromEnvLocal({ cwd: tempRoot, key: "VERCEL_TOKEN" })) ??
+      "";
+    const githubToken = await loadSecretFromEnvLocal({
+      cwd: tempRoot,
+      key: "GITHUB_TOKEN",
+    });
+    const result = await loadVercelBridgeOptions({
+      vercelToken,
+      githubToken,
+      cwd: tempRoot,
+    });
+
+    expect(result.loadError).toBeUndefined();
+    expect(result.scopes.length).toBeGreaterThan(0);
+  });
+
+  it("builds Vercel and Linear summaries with configured token presence in the same process", async () => {
+    await applyAllConnectServiceKeys();
+
+    const [vercelSummary, linearSummary] = await Promise.all([
+      buildVercelSetupSummary(tempRoot),
+      buildLinearSetupSummary(tempRoot),
+    ]);
+
+    expect(vercelSummary.vercelTokenConfigured).toBe(true);
+    expect(vercelSummary.linearApiKeyConfigured).toBe(true);
+    expect(linearSummary.linearApiKeyConfigured).toBe(true);
+  });
+
+  it("reads saved GitHub and Cursor tokens from disk without process.env", async () => {
+    await applyAllConnectServiceKeys();
+
+    const [githubToken, cursorApiKey] = await Promise.all([
+      loadGithubTokenFromEnvLocal({ cwd: tempRoot }),
+      loadSecretFromEnvLocal({ cwd: tempRoot, key: "CURSOR_API_KEY" }),
+    ]);
+
+    expect(githubToken).toBe(FAKE_SECRETS.githubToken);
+    expect(cursorApiKey).toBe(FAKE_SECRETS.cursorApiKey);
+    expect(process.env.GITHUB_TOKEN).toBeUndefined();
+    expect(process.env.CURSOR_API_KEY).toBeUndefined();
+  });
+
+  it("does not expose secret values in bridge options JSON", async () => {
+    await applyAllConnectServiceKeys();
+
+    const vercelToken =
+      (await loadSecretFromEnvLocal({ cwd: tempRoot, key: "VERCEL_TOKEN" })) ??
+      "";
+    const result = await loadVercelBridgeOptions({
+      vercelToken,
+      cwd: tempRoot,
+    });
+    const serialized = JSON.stringify(result);
+
+    for (const secret of Object.values(FAKE_SECRETS)) {
+      expect(serialized).not.toContain(secret);
+    }
+  });
+});

package/workspace-snapshot/files/tests/setup/connect-services-env.test.ts

@@ -0,0 +1,84 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  applyConnectServicesEnv,
+  computeConnectServicesFingerprint,
+  previewConnectServicesEnv,
+} from "../../src/setup/local-apply-actions";
+import { readExistingEnvFile } from "../../src/setup/env-merge";
+import { resolveLocalFilePaths } from "../../src/setup/setup-state";
+
+const FAKE_LINEAR_KEY = "fake-linear-key-for-test-only";
+const FAKE_VERCEL_TOKEN = "fake-vercel-token-for-test-only";
+
+describe("connect services env writes", () => {
+  let tempRoot = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-connect-services-"));
+    await mkdir(path.join(tempRoot, ".harness"), { recursive: true });
+    await writeFile(
+      path.join(tempRoot, ".env.example"),
+      "HARNESS_CONFIG_PATH=.harness/config.local.json\n",
+      "utf8",
+    );
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("previews connect-services env without requiring target repos", async () => {
+    const preview = await previewConnectServicesEnv({
+      cwd: tempRoot,
+      env: {
+        harnessConfigPath: ".harness/config.local.json",
+        linearApiKey: FAKE_LINEAR_KEY,
+      },
+    });
+
+    expect(preview.fingerprint).toBeTruthy();
+    expect(preview.envPreview).toContain("LINEAR_API_KEY=<redacted>");
+    expect(preview.envPreview).not.toContain(FAKE_LINEAR_KEY);
+    expect(preview.envKeyPresence.LINEAR_API_KEY).toBe(true);
+  });
+
+  it("applies a single verified service key without target repo config", async () => {
+    const env = {
+      harnessConfigPath: ".harness/config.local.json",
+      vercelToken: FAKE_VERCEL_TOKEN,
+    };
+    const preview = await previewConnectServicesEnv({ cwd: tempRoot, env });
+    const apply = await applyConnectServicesEnv({
+      cwd: tempRoot,
+      env,
+      confirmed: true,
+      fingerprint: preview.fingerprint,
+    });
+
+    expect(apply.envResult.outcome).toBe("changed");
+
+    const paths = resolveLocalFilePaths(tempRoot);
+    const existingEnv = await readExistingEnvFile(paths);
+    expect(existingEnv?.presence.VERCEL_TOKEN).toBe(true);
+  });
+
+  it("computeConnectServicesFingerprint ignores target repo config", () => {
+    const baselines = {
+      envLocalPath: path.join(tempRoot, ".env.local"),
+      configLocalPath: path.join(tempRoot, ".harness/config.local.json"),
+      envLocalHash: "env-hash",
+      configLocalHash: "config-hash",
+    };
+
+    expect(() =>
+      computeConnectServicesFingerprint(
+        { harnessConfigPath: ".harness/config.local.json" },
+        baselines,
+        tempRoot,
+      ),
+    ).not.toThrow();
+  });
+});

package/workspace-snapshot/files/tests/setup/control-plane-readiness.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { deriveVercelBridgeReadiness } from "../../src/setup/vercel-bridge-readiness.js";
+import { getDispatchTriggerStatuses } from "../../src/setup/linear-status-contract.js";
+import { requiredStatusNames } from "../../src/setup/linear-status-contract.js";
+
+function completeBridgeInput() {
+  return {
+    projectId: "prj_1",
+    productionUrl: "https://bridge.vercel.app",
+    webhookUrl: "https://bridge.vercel.app/api/linear-webhook",
+    endpointReachable: true,
+    requiredEnvPresence: {
+      LINEAR_WEBHOOK_SECRET: "present" as const,
+      GITHUB_DISPATCH_TOKEN: "present" as const,
+      HARNESS_TEAM_KEY: "present" as const,
+    },
+    linearWebhookVerified: true,
+    signedProbeVerified: true,
+    deploymentRedeployRequired: false,
+  };
+}
+
+describe("vercel bridge readiness", () => {
+  it("reports ready when all bridge checks pass", () => {
+    const readiness = deriveVercelBridgeReadiness(completeBridgeInput());
+
+    expect(readiness.ready).toBe(true);
+    expect(readiness.blockers).toHaveLength(0);
+  });
+
+  it("does not allow manual complete override without signed probe", () => {
+    const readiness = deriveVercelBridgeReadiness({
+      manualComplete: true,
+      signedProbeVerified: false,
+    });
+
+    expect(readiness.ready).toBe(false);
+    expect(readiness.manualComplete).toBe(true);
+  });
+
+  it("blocks readiness when signed probe has not passed", () => {
+    const readiness = deriveVercelBridgeReadiness({
+      ...completeBridgeInput(),
+      signedProbeVerified: false,
+    });
+
+    expect(readiness.ready).toBe(false);
+    expect(readiness.blockers.join(" ")).toMatch(/Signed webhook delivery verification/i);
+  });
+});
+
+describe("linear status contract", () => {
+  it("includes engineering review and dispatch triggers", () => {
+    const names = requiredStatusNames();
+    expect(names).toContain("Engineering Review");
+    expect(names).not.toContain("Plan Review");
+    expect(getDispatchTriggerStatuses()).toContain("Ready for Planning");
+  });
+});

package/workspace-snapshot/files/tests/setup/doctor-summary.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import {
+  doctorChecksFailed,
+  formatDoctorCheckLine,
+  summarizeDoctorChecks,
+} from "../../src/setup/doctor-summary.js";
+
+describe("doctor-summary", () => {
+  const checks = [
+    { label: "harness config valid", ok: true, detail: ".harness/config.local.json" },
+    { label: "LINEAR_API_KEY set", ok: true, detail: "authenticated as Operator" },
+    {
+      label: "CURSOR_API_KEY set",
+      ok: true,
+      skipped: true,
+      detail: "required only when merge integration repair needs a Cursor agent",
+    },
+    { label: "target-app base branch exists", ok: false, detail: "missing branch" },
+  ];
+
+  it("groups checks by provider area", () => {
+    const groups = summarizeDoctorChecks(checks);
+
+    expect(groups.map((group) => group.group)).toEqual([
+      "configuration",
+      "linear",
+      "cursor",
+      "github",
+    ]);
+  });
+
+  it("preserves pass, fail, and skipped formatting", () => {
+    expect(formatDoctorCheckLine(checks[0]!)).toBe(
+      "✓ harness config valid — .harness/config.local.json",
+    );
+    expect(formatDoctorCheckLine(checks[2]!)).toContain("○ CURSOR_API_KEY set");
+    expect(formatDoctorCheckLine(checks[3]!)).toContain("✗ target-app base branch exists");
+  });
+
+  it("detects failed checks while ignoring skipped checks", () => {
+    expect(doctorChecksFailed(checks)).toBe(true);
+    expect(
+      doctorChecksFailed([
+        { label: "CURSOR_API_KEY set", ok: true, skipped: true },
+      ]),
+    ).toBe(false);
+  });
+});