p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/tests/gui/observability-preferences-route.test.ts

@@ -0,0 +1,343 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { NextRequest } from "next/server";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { POST, GET } from "../../apps/gui/app/api/observability/preferences/route.js";
+import {
+  P_DEV_OBSERVABILITY_NONCE_ENV,
+} from "../../src/observability/constants.js";
+import {
+  getActiveObservabilitySession,
+  beginObservabilitySession,
+  createObservabilityTestRecorder,
+  shutdownObservability,
+  writeObservabilityPreferences,
+} from "../../src/observability/facade.js";
+import { ALLOWED_SENTRY_TAG_KEYS } from "../../src/observability/privacy-schema.js";
+import {
+  createObservabilityHandoff,
+  observabilityHandoffEnv,
+} from "../../src/observability/session-handoff.js";
+
+vi.mock("server-only", () => ({}));
+
+const packagedEnv = {
+  P_DEV_RUNTIME_MODE: "packaged",
+  P_DEV_PACKAGE_VERSION: "0.4.0",
+};
+
+function buildPreferencesRequest(
+  input: {
+    method?: "GET" | "POST";
+    body?: Record<string, unknown>;
+    nonce?: string;
+    host?: string;
+  } = {},
+): NextRequest {
+  const host = input.host ?? "127.0.0.1:4317";
+  const method = input.method ?? "POST";
+  const headers = new Headers({
+    host,
+    origin: `http://${host}`,
+    "content-type": "application/json",
+  });
+  if (method !== "GET" && input.nonce) {
+    headers.set("x-p-dev-observability-nonce", input.nonce);
+  }
+  return new NextRequest(`http://${host}/api/observability/preferences`, {
+    method,
+    headers,
+    body:
+      method === "GET" || input.body === undefined
+        ? undefined
+        : JSON.stringify(input.body),
+  });
+}
+
+describe("observability preferences route", () => {
+  let workspaceDir = "";
+  const originalRepoRoot = process.env.HARNESS_REPO_ROOT;
+  const originalRuntimeMode = process.env.P_DEV_RUNTIME_MODE;
+  const originalPackageVersion = process.env.P_DEV_PACKAGE_VERSION;
+  const originalGuiPort = process.env.HARNESS_GUI_PORT;
+  const originalGuiHost = process.env.HARNESS_GUI_HOST;
+  const originalNonceEnv = process.env[P_DEV_OBSERVABILITY_NONCE_ENV];
+
+  beforeEach(async () => {
+    workspaceDir = await mkdtemp(
+      path.join(tmpdir(), "observability-preferences-route-"),
+    );
+    process.env.HARNESS_REPO_ROOT = workspaceDir;
+    process.env.P_DEV_RUNTIME_MODE = packagedEnv.P_DEV_RUNTIME_MODE;
+    process.env.P_DEV_PACKAGE_VERSION = packagedEnv.P_DEV_PACKAGE_VERSION;
+    process.env.HARNESS_GUI_PORT = "4317";
+    process.env.HARNESS_GUI_HOST = "127.0.0.1";
+    await mkdir(path.join(workspaceDir, ".harness"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await shutdownObservability();
+    if (originalRepoRoot === undefined) {
+      delete process.env.HARNESS_REPO_ROOT;
+    } else {
+      process.env.HARNESS_REPO_ROOT = originalRepoRoot;
+    }
+    if (originalRuntimeMode === undefined) {
+      delete process.env.P_DEV_RUNTIME_MODE;
+    } else {
+      process.env.P_DEV_RUNTIME_MODE = originalRuntimeMode;
+    }
+    if (originalPackageVersion === undefined) {
+      delete process.env.P_DEV_PACKAGE_VERSION;
+    } else {
+      process.env.P_DEV_PACKAGE_VERSION = originalPackageVersion;
+    }
+    if (originalGuiPort === undefined) {
+      delete process.env.HARNESS_GUI_PORT;
+    } else {
+      process.env.HARNESS_GUI_PORT = originalGuiPort;
+    }
+    if (originalGuiHost === undefined) {
+      delete process.env.HARNESS_GUI_HOST;
+    } else {
+      process.env.HARNESS_GUI_HOST = originalGuiHost;
+    }
+    if (originalNonceEnv === undefined) {
+      delete process.env[P_DEV_OBSERVABILITY_NONCE_ENV];
+    } else {
+      process.env[P_DEV_OBSERVABILITY_NONCE_ENV] = originalNonceEnv;
+    }
+    await rm(workspaceDir, { recursive: true, force: true });
+  });
+
+  async function blockHarnessPersistence(): Promise<void> {
+    await rm(path.join(workspaceDir, ".harness"), { recursive: true, force: true });
+    await writeFile(path.join(workspaceDir, ".harness"), "blocked", "utf8");
+  }
+
+  async function startSessionWithConsent(options?: {
+    errorReportingEnabled?: boolean;
+    analyticsEnabled?: boolean;
+  }) {
+    const recorder = createObservabilityTestRecorder();
+    const errorReportingEnabled = options?.errorReportingEnabled ?? true;
+    const analyticsEnabled = options?.analyticsEnabled ?? false;
+    await writeObservabilityPreferences(workspaceDir, {
+      errorReportingPreference: errorReportingEnabled ? "enabled" : "disabled",
+      analyticsPreference: analyticsEnabled ? "enabled" : "disabled",
+      disclosureShown: true,
+    });
+    const handoff = createObservabilityHandoff();
+    process.env[P_DEV_OBSERVABILITY_NONCE_ENV] = handoff.nonce;
+    await beginObservabilitySession({
+      workspaceDir,
+      env: {
+        ...packagedEnv,
+        ...observabilityHandoffEnv(handoff),
+      },
+      fakeRecorder: recorder,
+    });
+    return { recorder, handoff };
+  }
+
+  it("persists a successful preference write", async () => {
+    const { handoff } = await startSessionWithConsent();
+    const response = await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "enabled",
+          analyticsPreference: "disabled",
+          disclosureShown: true,
+        },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      disclosureShown: boolean;
+      errorReportingPreference: string;
+      analyticsPreference: string | null;
+    };
+    expect(payload.disclosureShown).toBe(true);
+    expect(payload.errorReportingPreference).toBe("enabled");
+    expect(payload.analyticsPreference).toBe("disabled");
+  });
+
+  it("captures exactly one product error when preference persistence fails", async () => {
+    const { recorder, handoff } = await startSessionWithConsent();
+    await blockHarnessPersistence();
+
+    const response = await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "enabled",
+          analyticsPreference: "disabled",
+          disclosureShown: false,
+        },
+      }),
+    );
+
+    expect(response.status).toBe(500);
+    const payload = (await response.json()) as { error: string };
+    expect(payload.error).toBe("Could not save observability preferences.");
+    expect(JSON.stringify(payload)).not.toContain("EEXIST");
+    expect(JSON.stringify(payload)).not.toContain(workspaceDir);
+    expect(recorder.sentryEvents).toHaveLength(1);
+    expect(recorder.sentryEvents[0]?.tags?.product_error_code).toBe(
+      "configure_request_error",
+    );
+    expect(recorder.sentryEvents[0]?.tags?.lifecycle_phase).toBe(
+      "configure_route",
+    );
+    expect(recorder.sentryEvents[0]?.tags?.error_category).toBe("unexpected");
+    expect(recorder.sentryEvents[0]?.fingerprint).toEqual([
+      "configure_request_error",
+      "configure_route",
+    ]);
+  });
+
+  it("keeps consent unchanged after a failed preference write", async () => {
+    const { handoff } = await startSessionWithConsent();
+    await blockHarnessPersistence();
+
+    await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "enabled",
+          analyticsPreference: "disabled",
+          disclosureShown: false,
+        },
+      }),
+    );
+
+    const session = getActiveObservabilitySession();
+    expect(session?.consent.errorReportingEnabled).toBe(true);
+    expect(session?.consent.analyticsEnabled).toBe(false);
+    expect(session?.localState.errorReportingPreference).toBe("enabled");
+    expect(session?.localState.analyticsPreference).toBe("disabled");
+  });
+
+  it("does not capture when error reporting consent is disabled", async () => {
+    const { recorder, handoff } = await startSessionWithConsent({
+      errorReportingEnabled: false,
+    });
+    await blockHarnessPersistence();
+
+    const response = await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "disabled",
+          analyticsPreference: "disabled",
+          disclosureShown: true,
+        },
+      }),
+    );
+
+    expect(response.status).toBe(500);
+    expect(recorder.sentryEvents).toHaveLength(0);
+  });
+
+  it("keeps reset behavior unchanged and successful reset still works", async () => {
+    const { handoff } = await startSessionWithConsent();
+    await writeFile(
+      path.join(workspaceDir, ".harness", "observability.local.json"),
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          analyticsPreference: "enabled",
+          errorReportingPreference: "enabled",
+          disclosureShown: true,
+          installationId: "install-123",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          updatedAt: "2026-01-01T00:00:00.000Z",
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+
+    const response = await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: { reset: true },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      analyticsPreference: null;
+      errorReportingPreference: null;
+      hasInstallationId: boolean;
+    };
+    expect(payload.analyticsPreference).toBeNull();
+    expect(payload.errorReportingPreference).toBeNull();
+    expect(payload.hasInstallationId).toBe(false);
+  });
+
+  it("emits only allowlisted tags and sanitized exception metadata on capture", async () => {
+    const { recorder, handoff } = await startSessionWithConsent();
+    await blockHarnessPersistence();
+
+    await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "enabled",
+          analyticsPreference: "disabled",
+          disclosureShown: false,
+        },
+      }),
+    );
+
+    const event = recorder.sentryEvents[0]!;
+    const serialized = JSON.stringify(event);
+    expect(serialized).not.toContain(workspaceDir);
+    expect(serialized).not.toContain(handoff.nonce);
+    for (const key of Object.keys(event.tags ?? {})) {
+      expect(ALLOWED_SENTRY_TAG_KEYS).toContain(key);
+    }
+    const exceptionValue = event.exception?.values?.[0]?.value ?? "";
+    expect(exceptionValue).not.toContain(workspaceDir);
+  });
+
+  it("does not double-capture when the route handles the failure", async () => {
+    const { recorder, handoff } = await startSessionWithConsent();
+    await blockHarnessPersistence();
+
+    const response = await POST(
+      buildPreferencesRequest({
+        nonce: handoff.nonce,
+        body: {
+          errorReportingPreference: "enabled",
+          analyticsPreference: "disabled",
+          disclosureShown: false,
+        },
+      }),
+    );
+
+    expect(response.status).toBe(500);
+    expect(recorder.sentryEvents).toHaveLength(1);
+  });
+
+  it("serves GET preferences without mutation", async () => {
+    const { handoff } = await startSessionWithConsent();
+    const response = await GET(
+      buildPreferencesRequest({
+        method: "GET",
+        nonce: handoff.nonce,
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      errorReportingPreference: string;
+    };
+    expect(payload.errorReportingPreference).toBe("enabled");
+  });
+});

package/workspace-snapshot/files/tests/gui/observability-request-guard.test.ts

@@ -0,0 +1,177 @@
+import { NextRequest } from "next/server";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  OBSERVABILITY_REQUEST_MAX_BYTES,
+  P_DEV_OBSERVABILITY_NONCE_ENV,
+} from "../../src/observability/constants.js";
+import { guardObservabilityRequest } from "../../apps/gui/lib/observability-request-guard.js";
+
+function buildRequest(input: {
+  method?: "GET" | "POST";
+  host?: string;
+  origin?: string;
+  nonce?: string;
+  contentType?: string;
+  body?: string;
+  contentLength?: string;
+}): NextRequest {
+  const host = input.host ?? "127.0.0.1:4317";
+  const method = input.method ?? "POST";
+  const headers = new Headers({
+    host,
+    origin: input.origin ?? `http://${host}`,
+  });
+  if (input.contentType) {
+    headers.set("content-type", input.contentType);
+  }
+  if (input.nonce) {
+    headers.set("x-p-dev-observability-nonce", input.nonce);
+  }
+  if (input.contentLength) {
+    headers.set("content-length", input.contentLength);
+  }
+  return new NextRequest(`http://${host}/api/observability/preferences`, {
+    method,
+    headers,
+    body: method === "GET" ? undefined : input.body,
+  });
+}
+
+describe("guardObservabilityRequest", () => {
+  const originalPort = process.env.HARNESS_GUI_PORT;
+  const originalHost = process.env.HARNESS_GUI_HOST;
+  const originalNonce = process.env[P_DEV_OBSERVABILITY_NONCE_ENV];
+
+  beforeEach(() => {
+    process.env.HARNESS_GUI_PORT = "4317";
+    process.env.HARNESS_GUI_HOST = "127.0.0.1";
+    process.env[P_DEV_OBSERVABILITY_NONCE_ENV] = "expected-test-nonce";
+  });
+
+  afterEach(() => {
+    if (originalPort === undefined) {
+      delete process.env.HARNESS_GUI_PORT;
+    } else {
+      process.env.HARNESS_GUI_PORT = originalPort;
+    }
+    if (originalHost === undefined) {
+      delete process.env.HARNESS_GUI_HOST;
+    } else {
+      process.env.HARNESS_GUI_HOST = originalHost;
+    }
+    if (originalNonce === undefined) {
+      delete process.env[P_DEV_OBSERVABILITY_NONCE_ENV];
+    } else {
+      process.env[P_DEV_OBSERVABILITY_NONCE_ENV] = originalNonce;
+    }
+  });
+
+  it("accepts a valid same-origin POST with matching nonce", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        nonce: "expected-test-nonce",
+        contentType: "application/json",
+        body: JSON.stringify({ disclosureShown: true }),
+      }),
+    );
+    expect(result.ok).toBe(true);
+  });
+
+  it("rejects a wrong host", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        host: "127.0.0.1:9999",
+        nonce: "expected-test-nonce",
+        contentType: "application/json",
+        body: "{}",
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(403);
+      expect(await result.response.json()).toEqual({ error: "Forbidden host." });
+    }
+  });
+
+  it("rejects a wrong origin", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        origin: "http://evil.example:4317",
+        nonce: "expected-test-nonce",
+        contentType: "application/json",
+        body: "{}",
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(403);
+      expect(await result.response.json()).toEqual({ error: "Forbidden origin." });
+    }
+  });
+
+  it("rejects a missing nonce on POST", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        contentType: "application/json",
+        body: "{}",
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(403);
+      expect(await result.response.json()).toEqual({ error: "Invalid nonce." });
+    }
+  });
+
+  it("rejects an invalid nonce on POST", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        nonce: "wrong-nonce",
+        contentType: "application/json",
+        body: "{}",
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(403);
+    }
+  });
+
+  it("rejects a non-JSON content type", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        nonce: "expected-test-nonce",
+        contentType: "text/plain",
+        body: "{}",
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(415);
+    }
+  });
+
+  it("rejects an oversized payload", async () => {
+    const oversized = "x".repeat(OBSERVABILITY_REQUEST_MAX_BYTES + 1);
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        nonce: "expected-test-nonce",
+        contentType: "application/json",
+        body: JSON.stringify({ blob: oversized }),
+      }),
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(413);
+    }
+  });
+
+  it("allows GET without a nonce", async () => {
+    const result = await guardObservabilityRequest(
+      buildRequest({
+        method: "GET",
+      }),
+    );
+    expect(result.ok).toBe(true);
+  });
+});

package/workspace-snapshot/files/tests/gui/packaged-harness-cloud-secrets-routes.test.ts

@@ -25,6 +25,8 @@ describe("packaged harness cloud secrets route regression", () => {
   let workspaceDir = "";
   let provider: MockGitHubRemoteSetupProvider;
   const originalRepoRoot = process.env.HARNESS_REPO_ROOT;
+  const originalPDevHome = process.env.P_DEV_HOME;
+  const originalConfigPath = process.env.HARNESS_CONFIG_PATH;
   const originalRuntimeMode = process.env.P_DEV_RUNTIME_MODE;
   const originalPackagedVersion = process.env.P_DEV_PACKAGE_VERSION;
   const originalTestSeam = process.env.HARNESS_VITEST_REMOTE_SETUP_MOCK;
@@ -33,6 +35,10 @@ describe("packaged harness cloud secrets route regression", () => {
     process.env.P_DEV_RUNTIME_MODE = "packaged";
     process.env.P_DEV_PACKAGE_VERSION = "0.3.0";
     process.env.HARNESS_VITEST_REMOTE_SETUP_MOCK = "enabled";
+    // Prior apply/preview paths may absolutize HARNESS_CONFIG_PATH via dotenv load.
+    // Clear workspace-scoped env so each test resolves config inside its temp dir.
+    delete process.env.HARNESS_CONFIG_PATH;
+    delete process.env.P_DEV_HOME;
 
     workspaceDir = await mkdtemp(path.join(tmpdir(), "packaged-route-cloud-secrets-"));
     process.env.HARNESS_REPO_ROOT = workspaceDir;
@@ -93,6 +99,16 @@ describe("packaged harness cloud secrets route regression", () => {
     } else {
       process.env.HARNESS_REPO_ROOT = originalRepoRoot;
     }
+    if (originalPDevHome === undefined) {
+      delete process.env.P_DEV_HOME;
+    } else {
+      process.env.P_DEV_HOME = originalPDevHome;
+    }
+    if (originalConfigPath === undefined) {
+      delete process.env.HARNESS_CONFIG_PATH;
+    } else {
+      process.env.HARNESS_CONFIG_PATH = originalConfigPath;
+    }
     if (originalRuntimeMode === undefined) {
       delete process.env.P_DEV_RUNTIME_MODE;
     } else {