p-dev-harness 0.3.0 → 0.4.0

package/workspace-snapshot/files/scripts/configure-browser-matrix.spec.ts

@@ -0,0 +1,294 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { test, expect, type Page } from "@playwright/test";
+
+const screenshotDir = "/tmp/configure-validation";
+const workspaceMarkerPath = "/tmp/configure-browser-workspace-path.txt";
+
+function resolveWorkspaceDir(): string {
+  const fromEnv = process.env.CONFIGURE_BROWSER_WORKSPACE?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return readFileSync(workspaceMarkerPath, "utf8").trim();
+}
+
+const VERCEL_BRIDGE_OPTIONS = {
+  scopes: [{ id: "team-1", label: "Acme (acme)", kind: "team" }],
+  projects: [{ id: "proj-1", name: "harness-gui", accountId: "acct-1" }],
+  selectedScopeId: "team-1",
+  selectedProjectId: "proj-1",
+  harnessTeamKey: "ENG",
+  githubDispatch: {
+    eligible: true,
+    source: "saved-github-token",
+    repository: "weston-uribe/agentic-product-development-harness",
+    message:
+      "Saved GITHUB_TOKEN can dispatch to weston-uribe/agentic-product-development-harness.",
+  },
+  capabilities: {
+    teamCreate: true,
+    projectCreate: true,
+  },
+};
+
+function observabilityFilePath(): string {
+  const workspaceDir = resolveWorkspaceDir();
+  if (!workspaceDir) {
+    throw new Error("Configure browser workspace path is not available.");
+  }
+  return path.join(workspaceDir, ".harness/observability.local.json");
+}
+
+function setDisclosureShown(shown: boolean): void {
+  const filePath = observabilityFilePath();
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(
+    filePath,
+    `${JSON.stringify(
+      shown
+        ? {
+            schemaVersion: 1,
+            analyticsPreference: "disabled",
+            errorReportingPreference: "disabled",
+            disclosureShown: true,
+          }
+        : {
+            schemaVersion: 1,
+            analyticsPreference: null,
+            errorReportingPreference: null,
+            disclosureShown: false,
+          },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}
+
+async function mockConfigureApis(page: Page): Promise<void> {
+  await page.route("**/api/setup/vercel-bridge-options**", async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(VERCEL_BRIDGE_OPTIONS),
+    });
+  });
+}
+
+async function assertNoHorizontalOverflow(page: Page): Promise<void> {
+  const overflow = await page.evaluate(
+    () => document.documentElement.scrollWidth > window.innerWidth + 2,
+  );
+  expect(overflow).toBe(false);
+}
+
+async function openSettingsMenu(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Settings", exact: true }).click();
+}
+
+test.describe("configure browser matrix", () => {
+  test.beforeAll(() => {
+    mkdirSync(screenshotDir, { recursive: true });
+  });
+
+  test.describe("data sharing gate", () => {
+    test.beforeEach(() => {
+      setDisclosureShown(false);
+    });
+
+    test("blocks setup until continue succeeds", async ({ page }) => {
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toHaveCount(0);
+      await expect(page.getByText(/Step 1 of 7/)).toHaveCount(0);
+
+      await page.getByRole("button", { name: "Continue setup" }).click();
+
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toBeVisible();
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible();
+    });
+
+    test("supports keyboard continue setup", async ({ page }) => {
+      await page.goto("/settings/configure");
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+
+      await page.getByRole("button", { name: "Continue setup" }).focus();
+      await page.keyboard.press("Enter");
+
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible();
+    });
+
+    test("stays readable in dark theme", async ({ page }) => {
+      await page.emulateMedia({ colorScheme: "dark" });
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+      await assertNoHorizontalOverflow(page);
+    });
+
+    test("stays readable in light theme", async ({ page }) => {
+      await page.emulateMedia({ colorScheme: "light" });
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+      await assertNoHorizontalOverflow(page);
+    });
+
+    test("remains usable with reduced motion", async ({ page }) => {
+      await page.emulateMedia({ reducedMotion: "reduce" });
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+      await page.getByRole("button", { name: "Continue setup" }).click();
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible();
+    });
+
+    test("unchecked continue persists disabled preferences locally", async ({ page }) => {
+      await page.goto("/settings/configure");
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+
+      await page.getByRole("button", { name: "Continue setup" }).click();
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toBeVisible();
+
+      const persisted = JSON.parse(readFileSync(observabilityFilePath(), "utf8")) as {
+        analyticsPreference: string;
+        errorReportingPreference: string;
+        disclosureShown: boolean;
+      };
+      expect(persisted.disclosureShown).toBe(true);
+      expect(persisted.analyticsPreference).toBe("disabled");
+      expect(persisted.errorReportingPreference).toBe("disabled");
+    });
+
+    test("failed save keeps the data sharing gate visible", async ({ page }) => {
+      await page.route("**/api/observability/preferences", async (route) => {
+        if (route.request().method() === "POST") {
+          await route.fulfill({ status: 500, body: JSON.stringify({ error: "fail" }) });
+          return;
+        }
+        await route.continue();
+      });
+
+      await page.goto("/settings/configure");
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible({ timeout: 30_000 });
+      await page.getByRole("button", { name: "Continue setup" }).click();
+
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible();
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toHaveCount(0);
+      await expect(page.getByText(/Could not save data sharing preferences/i)).toBeVisible();
+    });
+
+    test("reload bypasses onboarding when disclosure was already shown", async ({ page }) => {
+      setDisclosureShown(true);
+      await page.goto("/settings/configure");
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toBeVisible({ timeout: 30_000 });
+      await expect(page.getByText(/^Data sharing$/)).toHaveCount(0);
+
+      await page.reload();
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toBeVisible();
+      await expect(page.getByText(/^Data sharing$/)).toHaveCount(0);
+    });
+  });
+
+  test.describe("guided configure flow", () => {
+    test.beforeEach(() => {
+      setDisclosureShown(true);
+    });
+
+    test("settings menu exposes data sharing from configure", async ({ page }) => {
+      await mockConfigureApis(page);
+      await page.goto("/settings/configure");
+      await expect(
+        page.getByRole("heading", { name: "Initial Harness Configuration" }),
+      ).toBeVisible({ timeout: 30_000 });
+
+      await openSettingsMenu(page);
+      await page.getByRole("menuitem", { name: "Data sharing" }).click();
+
+      await expect(page).toHaveURL(/\/settings\/data-sharing$/);
+      await expect(page.getByText(/^Data sharing$/)).toBeVisible();
+      await expect(page.getByRole("button", { name: "Save changes" })).toBeVisible();
+    });
+
+    test("step 3 shows dispatch eligibility and back navigation returns to step 2", async ({
+      page,
+    }) => {
+      await mockConfigureApis(page);
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible({
+        timeout: 30_000,
+      });
+
+      await expect(
+        page.getByText(/Could not resolve the harness dispatch repository/i),
+      ).toHaveCount(0);
+
+      await page.getByRole("button", { name: "Back" }).click();
+
+      await expect(
+        page.getByText(/Step 2 of 7 · Set up Linear workspace/),
+      ).toBeVisible();
+
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toHaveCount(
+        0,
+      );
+
+      await page.waitForTimeout(1_000);
+
+      await expect(
+        page.getByText(/Step 2 of 7 · Set up Linear workspace/),
+      ).toBeVisible();
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toHaveCount(
+        0,
+      );
+
+      await page.getByRole("button", { name: "Continue to Vercel bridge" }).click();
+
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible();
+      await expect(page.getByRole("button", { name: "Apply Vercel Settings" })).toBeVisible();
+
+      await page.screenshot({
+        path: `${screenshotDir}/configure-step3-back-desktop.png`,
+        fullPage: true,
+      });
+    });
+
+    test("mobile step 3 back navigation remains usable", async ({ page }) => {
+      await page.setViewportSize({ width: 390, height: 844 });
+      await mockConfigureApis(page);
+      await page.goto("/settings/configure");
+
+      await expect(page.getByText(/Step 3 of 7 · Configure Vercel settings/)).toBeVisible({
+        timeout: 30_000,
+      });
+
+      await page.getByRole("button", { name: "Back" }).click();
+      await expect(
+        page.getByText(/Step 2 of 7 · Set up Linear workspace/),
+      ).toBeVisible();
+
+      await assertNoHorizontalOverflow(page);
+      await page.screenshot({
+        path: `${screenshotDir}/configure-step3-back-mobile.png`,
+        fullPage: true,
+      });
+    });
+  });
+});

package/workspace-snapshot/files/scripts/configure-step4-harness-readiness.config.ts

@@ -0,0 +1,118 @@
+import { execSync } from "node:child_process";
+import { copyFileSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "@playwright/test";
+
+const repoRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+const workspaceDir = execSync("npx tsx scripts/prepare-configure-browser-workspace.ts", {
+  cwd: repoRoot,
+  encoding: "utf8",
+}).trim();
+
+copyFileSync(
+  path.join(repoRoot, ".env.example"),
+  path.join(workspaceDir, ".env.example"),
+);
+copyFileSync(
+  path.join(repoRoot, ".harness/config.example.json"),
+  path.join(workspaceDir, ".harness/config.example.json"),
+);
+
+writeFileSync(
+  path.join(workspaceDir, ".env.local"),
+  [
+    "HARNESS_CONFIG_PATH=.harness/config.local.json",
+    "GITHUB_DISPATCH_REPOSITORY=weston-uribe/agentic-product-development-harness",
+    "LINEAR_API_KEY=lin_test_key",
+    "CURSOR_API_KEY=crsr_test_key",
+    "GITHUB_TOKEN=ghp_test_key",
+    "VERCEL_TOKEN=vcp_test_key",
+  ].join("\n"),
+  "utf8",
+);
+writeFileSync(
+  path.join(workspaceDir, ".harness/control-plane-setup.json"),
+  `${JSON.stringify(
+    {
+      version: 1,
+      linear: {
+        teamMode: "existing",
+        teamId: "team-1",
+        teamKey: "ENG",
+        teamName: "Engineering",
+        projectMode: "existing",
+        projectId: "proj-1",
+        projectName: "Harness",
+        statusCoverageComplete: true,
+        appliedAt: "2026-07-16T00:00:00.000Z",
+      },
+      vercel: {
+        projectId: "prj-1",
+        projectName: "harness-bridge",
+        productionUrl: "https://harness-bridge.vercel.app",
+        webhookUrl: "https://harness-bridge.vercel.app/api/linear-webhook",
+        endpointReachable: true,
+        envVarPresence: {
+          LINEAR_WEBHOOK_SECRET: "present",
+          GITHUB_DISPATCH_TOKEN: "present",
+          HARNESS_TEAM_KEY: "present",
+        },
+        linearWebhookVerified: true,
+        signedProbeVerified: true,
+        deploymentRedeployRequired: false,
+        appliedAt: "2026-07-16T00:00:00.000Z",
+      },
+    },
+    null,
+    2,
+  )}\n`,
+  "utf8",
+);
+try {
+  unlinkSync(path.join(workspaceDir, ".harness/config.local.json"));
+} catch {
+  // Step 4 runs before local config files exist.
+}
+writeFileSync(
+  path.join(workspaceDir, ".harness/observability.local.json"),
+  `${JSON.stringify(
+    {
+      schemaVersion: 1,
+      analyticsPreference: "disabled",
+      errorReportingPreference: "disabled",
+      disclosureShown: true,
+    },
+    null,
+    2,
+  )}\n`,
+  "utf8",
+);
+
+process.env.CONFIGURE_STEP4_WORKSPACE = workspaceDir;
+
+export default defineConfig({
+  testDir: path.join(repoRoot, "scripts"),
+  testMatch: "configure-step4-harness-readiness.spec.ts",
+  timeout: 120_000,
+  workers: 1,
+  use: {
+    baseURL: "http://localhost:3110",
+    screenshot: "only-on-failure",
+    trace: "off",
+  },
+  webServer: {
+    command: [
+      `P_DEV_HOME=${workspaceDir}`,
+      "P_DEV_RUNTIME_MODE=source",
+      "P_DEV_OBSERVABILITY_DISABLED=1",
+      "CONFIGURE_BROWSER_SKIP_DISCLOSURE=1",
+      "npx tsx src/gui/start-gui.ts --port 3110 --route /settings/configure",
+    ].join(" "),
+    cwd: repoRoot,
+    url: "http://localhost:3110/settings/configure",
+    reuseExistingServer: false,
+    timeout: 180_000,
+  },
+  outputDir: "/tmp/configure-step4-readiness/playwright-results",
+});

package/workspace-snapshot/files/scripts/configure-step4-harness-readiness.spec.ts

@@ -0,0 +1,80 @@
+import { test, expect } from "@playwright/test";
+
+test.describe("configure step 4 harness readiness", () => {
+  test("enables create local setup files without false harness verify prompts", async ({
+    page,
+  }) => {
+    await page.route("**/api/setup/harness-provisioning-summary", async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          runtimeMode: "source",
+          eligible: false,
+          state: "skipped-source-mode",
+          harnessDispatchRepo: "weston-uribe/agentic-product-development-harness",
+          authenticatedLogin: null,
+          message:
+            "Using harness workspace weston-uribe/agentic-product-development-harness from Step 1 setup.",
+          recoverable: false,
+          connectedAutomatically: false,
+          verifiedSavedRepo: true,
+        }),
+      });
+    });
+
+    await page.route("**/api/setup/verify-target-repo", async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          status: "connected",
+          message:
+            "Connected to acme/example-target-app with repo + workflow install access.",
+          repoSlug: "acme/example-target-app",
+          workflowInstallReady: true,
+        }),
+      });
+    });
+
+    await page.goto("/settings/configure");
+
+    await expect(
+      page.getByText(/Step 4 of 7 · Choose target repo\(s\) and create setup files/),
+    ).toBeVisible({ timeout: 30_000 });
+
+    await expect(
+      page.getByText(
+        "Verify and use this harness repo before creating local setup files.",
+      ),
+    ).toHaveCount(0);
+    await expect(
+      page.getByText(
+        "Verify and use your harness repo before creating local setup files.",
+      ),
+    ).toHaveCount(0);
+
+    await page
+      .getByPlaceholder("https://github.com/acme/my-product")
+      .fill("https://github.com/acme/example-target-app");
+
+    const verifyRepoButton = page.getByRole("button", {
+      name: "Verify repo + workflow access",
+    });
+    if (await verifyRepoButton.isEnabled()) {
+      await verifyRepoButton.click();
+    }
+
+    await expect(page.getByRole("button", { name: "Verified" })).toBeVisible();
+
+    await page
+      .getByRole("checkbox", {
+        name: "I understand this will create local setup files on this machine.",
+      })
+      .check();
+
+    await expect(
+      page.getByRole("button", { name: "Create local setup files" }),
+    ).toBeEnabled();
+  });
+});

package/workspace-snapshot/files/scripts/generate-config-schema.ts

@@ -0,0 +1,16 @@
+import { writeFile } from "node:fs/promises";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { harnessConfigSchema } from "../src/config/schema.js";
+
+const schema = zodToJsonSchema(harnessConfigSchema, {
+  name: "HarnessConfig",
+  $refStrategy: "none",
+});
+
+await writeFile(
+  "harness.config.schema.json",
+  `${JSON.stringify(schema, null, 2)}\n`,
+  "utf8",
+);
+
+console.log("Wrote harness.config.schema.json");

package/workspace-snapshot/files/scripts/prepare-configure-browser-workspace.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+async function ensureGitRepo(dir: string): Promise<void> {
+  const gitDir = path.join(dir, ".git");
+  try {
+    await access(gitDir);
+  } catch {
+    await execFileAsync("git", ["init"], { cwd: dir });
+    await execFileAsync("git", ["config", "user.email", "configure-browser@test.local"], {
+      cwd: dir,
+    });
+    await execFileAsync("git", ["config", "user.name", "Configure Browser Test"], {
+      cwd: dir,
+    });
+  }
+
+  try {
+    await execFileAsync(
+      "git",
+      [
+        "remote",
+        "add",
+        "origin",
+        "https://github.com/weston-uribe/agentic-product-development-harness.git",
+      ],
+      { cwd: dir },
+    );
+  } catch {
+    await execFileAsync(
+      "git",
+      [
+        "remote",
+        "set-url",
+        "origin",
+        "https://github.com/weston-uribe/agentic-product-development-harness.git",
+      ],
+      { cwd: dir },
+    );
+  }
+}
+
+async function main(): Promise<void> {
+  const configured = process.env.CONFIGURE_BROWSER_WORKSPACE?.trim();
+  const workspaceDir =
+    configured ||
+    path.join(tmpdir(), `configure-browser-${process.pid}-${Date.now()}`);
+
+  await mkdir(path.join(workspaceDir, ".harness"), { recursive: true });
+  await ensureGitRepo(workspaceDir);
+
+  await writeFile(
+    path.join(workspaceDir, ".env.local"),
+    [
+      "LINEAR_API_KEY=linear-browser-test-token",
+      "CURSOR_API_KEY=cursor-browser-test-token",
+      "GITHUB_TOKEN=github-browser-test-token",
+      "VERCEL_TOKEN=vercel-browser-test-token",
+      "HARNESS_CONFIG_PATH=.harness/config.local.json",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+
+  await writeFile(
+    path.join(workspaceDir, ".harness/config.local.json"),
+    `${JSON.stringify(
+      {
+        repos: [
+          {
+            id: "target-app",
+            targetRepo: "https://github.com/owner/example-target-app",
+            baseBranch: "dev",
+            productionBranch: "main",
+          },
+        ],
+        linearTeamKey: "ENG",
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  await writeFile(
+    path.join(workspaceDir, ".harness/control-plane-setup.json"),
+    `${JSON.stringify(
+      {
+        version: 1,
+        linear: {
+          teamMode: "existing",
+          teamId: "team-1",
+          teamKey: "ENG",
+          teamName: "Engineering",
+          projectMode: "existing",
+          projectId: "proj-1",
+          projectName: "Harness",
+          statusCoverageComplete: true,
+          appliedAt: "2026-07-16T00:00:00.000Z",
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  const skipDisclosure = process.env.CONFIGURE_BROWSER_SKIP_DISCLOSURE === "1";
+  if (!skipDisclosure) {
+    await writeFile(
+      path.join(workspaceDir, ".harness/observability.local.json"),
+      `${JSON.stringify(
+        {
+          analyticsPreference: "disabled",
+          errorReportingPreference: "disabled",
+          disclosureShown: true,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+
+  process.stdout.write(`${workspaceDir}\n`);
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`prepare-configure-browser-workspace failed: ${message}`);
+  process.exit(1);
+});