p-dev-harness 0.3.0 → 0.3.1

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import {
+  deriveRepoConfigIdFromUrl,
+  deriveUniqueRepoConfigIds,
+  prepareGuidedConfigFormInput,
+} from "../../src/setup/guided-config-form.js";
+import { validateConfigFormInput } from "../../src/setup/config-local-editor.js";
+
+describe("guided-config-form", () => {
+  it("derives repo config id from target repo URL", () => {
+    expect(
+      deriveRepoConfigIdFromUrl("https://github.com/acme/my-product"),
+    ).toBe("my-product");
+  });
+
+  it("prepares guided config for multiple repos", () => {
+    const prepared = prepareGuidedConfigFormInput({
+      repos: [
+        { id: "", targetRepo: "https://github.com/acme/my-product" },
+        { id: "", targetRepo: "https://github.com/acme/another-app" },
+      ],
+    });
+
+    expect(prepared.repos).toHaveLength(2);
+    expect(prepared.repos[0]?.id).toBe("my-product");
+    expect(prepared.repos[1]?.id).toBe("another-app");
+  });
+
+  it("handles duplicate repo names with stable suffixes", () => {
+    const ids = deriveUniqueRepoConfigIds([
+      { id: "", targetRepo: "https://github.com/acme/my-app" },
+      { id: "", targetRepo: "https://github.com/other/my-app" },
+      { id: "", targetRepo: "https://github.com/third/my-app" },
+    ]);
+
+    expect(ids).toEqual(["my-app", "my-app-2", "my-app-3"]);
+  });
+
+  it("builds allowedTargetRepos closure for multiple guided repos", () => {
+    const { config } = validateConfigFormInput(
+      prepareGuidedConfigFormInput({
+        repos: [
+          { id: "", targetRepo: "https://github.com/acme/my-product" },
+          { id: "", targetRepo: "https://github.com/acme/another-app" },
+        ],
+      }),
+    );
+
+    expect(config.allowedTargetRepos).toEqual([
+      "https://github.com/acme/my-product",
+      "https://github.com/acme/another-app",
+    ]);
+  });
+});

package/workspace-snapshot/files/tests/setup/harness-dispatch-repo.test.ts

@@ -0,0 +1,105 @@
+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 {
+  MANUAL_HARNESS_DISPATCH_REPO_PLACEHOLDER,
+  parseGitHubRepoSlug,
+  resolveHarnessDispatchRepo,
+  resolveHarnessDispatchRepoFromInputs,
+} from "../../src/setup/harness-dispatch-repo.js";
+
+describe("harness-dispatch-repo", () => {
+  let tempRoot = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-dispatch-repo-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("parses https and ssh GitHub remote URLs", () => {
+    expect(
+      parseGitHubRepoSlug("https://github.com/owner/example-harness.git"),
+    ).toBe("owner/example-harness");
+    expect(parseGitHubRepoSlug("git@github.com:owner/example-harness.git")).toBe(
+      "owner/example-harness",
+    );
+    expect(parseGitHubRepoSlug("owner/example-harness")).toBe(
+      "owner/example-harness",
+    );
+  });
+
+  it("prefers explicit setup/config value over git remote origin", () => {
+    const resolution = resolveHarnessDispatchRepoFromInputs({
+      explicitRepo: "explicit-org/explicit-repo",
+      gitRemoteOriginUrl: "https://github.com/origin-org/origin-repo.git",
+    });
+
+    expect(resolution).toEqual({
+      repo: "explicit-org/explicit-repo",
+      source: "explicit-config",
+      resolved: true,
+      detail: "Resolved from explicit setup/config value.",
+    });
+  });
+
+  it("falls back to git remote origin when explicit value is absent", () => {
+    const resolution = resolveHarnessDispatchRepoFromInputs({
+      gitRemoteOriginUrl: "https://github.com/origin-org/origin-repo.git",
+    });
+
+    expect(resolution.source).toBe("git-remote-origin");
+    expect(resolution.repo).toBe("origin-org/origin-repo");
+    expect(resolution.resolved).toBe(true);
+  });
+
+  it("uses manual fallback when neither explicit nor origin resolve", () => {
+    const unresolved = resolveHarnessDispatchRepoFromInputs({});
+    expect(unresolved.resolved).toBe(false);
+    expect(unresolved.repo).toBeNull();
+
+    const manual = resolveHarnessDispatchRepoFromInputs({
+      manualRepo: "manual-org/manual-repo",
+    });
+    expect(manual.source).toBe("manual");
+    expect(manual.repo).toBe("manual-org/manual-repo");
+  });
+
+  it("reads GITHUB_DISPATCH_REPOSITORY from .env.local", async () => {
+    await writeFile(
+      path.join(tempRoot, ".env.local"),
+      "GITHUB_DISPATCH_REPOSITORY=env-org/env-repo\n",
+      "utf8",
+    );
+
+    const resolution = await resolveHarnessDispatchRepo({ cwd: tempRoot });
+    expect(resolution.repo).toBe("env-org/env-repo");
+    expect(resolution.source).toBe("explicit-config");
+  });
+
+  it("reads git remote origin from .git/config", async () => {
+    const gitDir = path.join(tempRoot, ".git");
+    await mkdir(gitDir, { recursive: true });
+    await writeFile(
+      path.join(gitDir, "config"),
+      `[remote "origin"]\n\turl = https://github.com/git-org/git-repo.git\n`,
+      "utf8",
+    );
+
+    const resolution = await resolveHarnessDispatchRepo({ cwd: tempRoot });
+    expect(resolution.repo).toBe("git-org/git-repo");
+    expect(resolution.source).toBe("git-remote-origin");
+  });
+
+  it("returns manual placeholder when unresolved", async () => {
+    const resolution = await resolveHarnessDispatchRepo({ cwd: tempRoot });
+    expect(resolution.resolved).toBe(false);
+    expect(resolution.repo).toBeNull();
+    expect(MANUAL_HARNESS_DISPATCH_REPO_PLACEHOLDER).toBe(
+      "<harness-dispatch-repo>",
+    );
+  });
+});

package/workspace-snapshot/files/tests/setup/harness-managed-repo-marker.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildHarnessManagedRepoMarker,
+  parseHarnessManagedRepoMarkerJson,
+  validateManagedMarkerForReconnect,
+} from "../../src/setup/harness-managed-repo-marker.js";
+
+const TEMPLATE_IDENTITY = {
+  schemaVersion: 1,
+  product: "p-dev",
+  role: "harness-template",
+  templateIdentity: "p-dev-harness-template",
+  templateVersion: 1,
+  compatibilityVersion: 1,
+  templateContentId: "template-content-v1",
+};
+
+function validMarker(overrides: Record<string, unknown> = {}) {
+  const marker = buildHarnessManagedRepoMarker({
+    repository: "test-user/p-dev-harness",
+    repositoryId: 100_001,
+    templateIdentity: TEMPLATE_IDENTITY,
+    defaultBranch: "main",
+    sourceHeadSha: "abc123templatehead",
+    operationId: "op-1",
+    createdByGithubUserId: 1,
+    createdByLogin: "test-user",
+    pDevVersion: "0.3.0",
+  });
+  return { ...marker, ...overrides };
+}
+
+describe("harness managed repo marker", () => {
+  it("rejects missing templateRepository", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        templateRepository: "",
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects wrong templateRepository", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        templateRepository: "other/template",
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects missing defaultBranch", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        defaultBranch: "",
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects missing templateVersion", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        templateVersion: undefined,
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects wrong compatibility version", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        compatibilityVersion: 2,
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects malformed template identity", () => {
+    const marker = validMarker();
+    const broken = {
+      ...marker,
+      createdFromTemplate: {
+        ...marker.createdFromTemplate,
+        templateIdentity: "not-a-valid-identity",
+      },
+    };
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(broken));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects marker repository mismatch on reconnect validation", () => {
+    const marker = validMarker();
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(marker));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) {
+      return;
+    }
+    const reconnect = validateManagedMarkerForReconnect(
+      parsed.marker,
+      "other-user/p-dev-harness",
+      { repositoryId: parsed.marker.repositoryId! },
+    );
+    expect(reconnect.ok).toBe(false);
+  });
+
+  it("rejects parseable marker from a different repo slug", () => {
+    const marker = validMarker({ repository: "other-user/p-dev-harness" });
+    const parsed = parseHarnessManagedRepoMarkerJson(JSON.stringify(marker));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) {
+      return;
+    }
+    const reconnect = validateManagedMarkerForReconnect(
+      parsed.marker,
+      "test-user/p-dev-harness",
+      { repositoryId: parsed.marker.repositoryId! },
+    );
+    expect(reconnect.ok).toBe(false);
+  });
+});

package/workspace-snapshot/files/tests/setup/harness-provisioning-context.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildHarnessProvisioningPreviewContext,
+  compareHarnessProvisioningPreviewContexts,
+  diagnoseHarnessProvisioningFingerprintMismatch,
+  serializeHarnessProvisioningPreviewContext,
+} from "../../src/setup/harness-provisioning-context.js";
+import { buildTestWorkspaceSnapshotManifest } from "./test-workspace-snapshot-fixture.js";
+import { fingerprintWorkspaceSnapshotManifest } from "../../src/p-dev/workspace-snapshot-manifest.js";
+
+function buildContext(
+  overrides: Partial<Parameters<typeof buildHarnessProvisioningPreviewContext>[0]> = {},
+) {
+  const manifest = buildTestWorkspaceSnapshotManifest("0.3.0");
+  return buildHarnessProvisioningPreviewContext({
+    operationId: "op-1",
+    user: { id: 1, login: "Test-User" },
+    destination: "Test-User/p-dev-harness",
+    manifest,
+    snapshotFingerprint: fingerprintWorkspaceSnapshotManifest(manifest),
+    classification: "absent",
+    envBaseline: "",
+    pDevVersion: "0.3.0",
+    resumedFromPending: false,
+    creationPreviewFingerprint: null,
+    ...overrides,
+  });
+}
+
+describe("harness provisioning context", () => {
+  it("normalizes login and destination casing in serialized fingerprints", () => {
+    const context = buildContext();
+    const fingerprint = serializeHarnessProvisioningPreviewContext(context);
+    const parsed = JSON.parse(fingerprint) as {
+      authenticatedLogin: string;
+      destination: string;
+    };
+    expect(parsed.authenticatedLogin).toBe("test-user");
+    expect(parsed.destination).toBe("test-user/p-dev-harness");
+  });
+
+  it("accepts unchanged preview then apply context", () => {
+    const current = buildContext();
+    const fingerprint = serializeHarnessProvisioningPreviewContext(current);
+    const diagnosis = diagnoseHarnessProvisioningFingerprintMismatch({
+      submittedFingerprint: fingerprint,
+      currentContext: current,
+    });
+    expect(diagnosis.ok).toBe(true);
+  });
+
+  it("rejects genuine source commit changes with a redacted field name", () => {
+    const submitted = serializeHarnessProvisioningPreviewContext(buildContext());
+    const manifest = buildTestWorkspaceSnapshotManifest("0.3.0");
+    const current = buildContext({
+      manifest: {
+        ...manifest,
+        sourceCommit: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+      },
+    });
+    const diagnosis = diagnoseHarnessProvisioningFingerprintMismatch({
+      submittedFingerprint: submitted,
+      currentContext: current,
+    });
+    expect(diagnosis.ok).toBe(false);
+    if (!diagnosis.ok) {
+      expect(diagnosis.mismatchedField).toBe("sourceCommit");
+      expect(diagnosis.message).not.toContain("ghp_");
+    }
+  });
+
+  it("rejects pDevVersion mismatch", () => {
+    const submitted = serializeHarnessProvisioningPreviewContext(buildContext());
+    const current = buildContext({ pDevVersion: "0.2.0" });
+    const comparison = compareHarnessProvisioningPreviewContexts(
+      buildContext(),
+      current,
+    );
+    expect(comparison.ok).toBe(false);
+    if (!comparison.ok) {
+      expect(comparison.mismatchedField).toBe("pDevVersion");
+    }
+    const diagnosis = diagnoseHarnessProvisioningFingerprintMismatch({
+      submittedFingerprint: submitted,
+      currentContext: current,
+    });
+    expect(diagnosis.ok).toBe(false);
+  });
+});

package/workspace-snapshot/files/tests/setup/harness-provisioning-pending-state.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildPendingValidationContext,
+  validatePendingProvisioningState,
+  withHarnessProvisioningMutex,
+} from "../../src/setup/harness-provisioning-pending-state.js";
+import { buildTestSnapshotPendingState, buildTestWorkspaceSnapshotManifest } from "./test-workspace-snapshot-fixture.js";
+
+describe("harness provisioning pending state", () => {
+  it("serializes workspace mutex calls and releases afterward", async () => {
+    const order: string[] = [];
+
+    const first = withHarnessProvisioningMutex("/tmp/workspace-a", async () => {
+      order.push("first-start");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      order.push("first-end");
+      return "first";
+    });
+
+    const second = withHarnessProvisioningMutex("/tmp/workspace-a", async () => {
+      order.push("second-start");
+      order.push("second-end");
+      return "second";
+    });
+
+    const [firstResult, secondResult] = await Promise.all([first, second]);
+    expect(firstResult).toBe("first");
+    expect(secondResult).toBe("second");
+    expect(order).toEqual([
+      "first-start",
+      "first-end",
+      "second-start",
+      "second-end",
+    ]);
+
+    let thirdStarted = false;
+    await withHarnessProvisioningMutex("/tmp/workspace-a", async () => {
+      thirdStarted = true;
+    });
+    expect(thirdStarted).toBe(true);
+  });
+
+  it("validates the full pending provisioning context strictly", () => {
+    const manifest = buildTestWorkspaceSnapshotManifest("0.3.0");
+    const pending = buildTestSnapshotPendingState(manifest, {
+      operationId: "op-1",
+      previewFingerprint: "creation-fingerprint",
+    });
+
+    const valid = validatePendingProvisioningState(
+      pending,
+      buildPendingValidationContext({
+        operationId: "op-1",
+        authenticatedUserId: 1,
+        authenticatedLogin: "test-user",
+        targetOwner: "test-user",
+        targetRepo: "p-dev-harness",
+        packageVersion: manifest.packageVersion,
+        sourceCommit: manifest.sourceCommit,
+        manifestSchemaVersion: manifest.schemaVersion,
+        snapshotContentId: manifest.snapshotContentId,
+        snapshotSha256: manifest.snapshotSha256,
+        snapshotGitTreeSha1: manifest.gitRootTreeSha1,
+        previewFingerprint: "creation-fingerprint",
+      }),
+    );
+    expect(valid.ok).toBe(true);
+
+    const wrongUser = validatePendingProvisioningState(
+      pending,
+      buildPendingValidationContext({
+        operationId: "op-1",
+        authenticatedUserId: 2,
+        authenticatedLogin: "other-user",
+        targetOwner: "test-user",
+        targetRepo: "p-dev-harness",
+        packageVersion: manifest.packageVersion,
+        sourceCommit: manifest.sourceCommit,
+        manifestSchemaVersion: manifest.schemaVersion,
+        snapshotContentId: manifest.snapshotContentId,
+        snapshotSha256: manifest.snapshotSha256,
+        snapshotGitTreeSha1: manifest.gitRootTreeSha1,
+        previewFingerprint: "creation-fingerprint",
+      }),
+    );
+    expect(wrongUser.ok).toBe(false);
+  });
+});