p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/tests/setup/release-sync-managed-runner.test.ts

@@ -0,0 +1,385 @@
+import { 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, vi } from "vitest";
+import { computeGitBlobSha1 } from "../../src/p-dev/git-object-plumbing.js";
+import {
+  buildWorkspaceSnapshotManifest,
+  fingerprintWorkspaceSnapshotManifest,
+} from "../../src/p-dev/workspace-snapshot-manifest.js";
+import type { WorkspaceSnapshotManifest } from "../../src/p-dev/workspace-snapshot-types.js";
+import {
+  buildHarnessSnapshotManagedRepoMarker,
+  HARNESS_MANAGED_REPO_MARKER_FILE,
+} from "../../src/setup/harness-managed-repo-marker.js";
+import { createMockRunnerUpgradeProvider } from "../../src/setup/runner-upgrade-provider.js";
+import { readRunnerUpgradePendingState } from "../../src/setup/runner-upgrade-pending-state.js";
+import {
+  RELEASE_SYNC_EXPECTED_REPOSITORY_ID,
+  RELEASE_SYNC_EXPECTED_REPO_SLUG,
+  ReleaseSyncManagedRunnerError,
+  runReleaseSyncManagedRunner,
+} from "../../src/setup/release-sync-managed-runner.js";
+import { isRunnerUpgradeUiEnabled } from "../../apps/gui/lib/settings/runner-upgrade-feature-flag.js";
+import { createTestWorkspaceSnapshotRoot } from "./test-workspace-snapshot-fixture.js";
+
+const REPO_SLUG = RELEASE_SYNC_EXPECTED_REPO_SLUG;
+const REPO_ID = RELEASE_SYNC_EXPECTED_REPOSITORY_ID;
+const README_V1 = Buffer.from("# runner v1\n", "utf8");
+const README_V2 = Buffer.from("# runner v2\n", "utf8");
+
+const snapshotFixture = vi.hoisted(() => {
+  const state = {
+    snapshotRoot: "",
+    packageRoot: "",
+    manifest: null as WorkspaceSnapshotManifest | null,
+    fingerprint: "",
+  };
+  return {
+    get snapshotRoot() {
+      return state.snapshotRoot;
+    },
+    set snapshotRoot(value: string) {
+      state.snapshotRoot = value;
+    },
+    get packageRoot() {
+      return state.packageRoot;
+    },
+    set packageRoot(value: string) {
+      state.packageRoot = value;
+    },
+    get manifest() {
+      return state.manifest;
+    },
+    set manifest(value: WorkspaceSnapshotManifest | null) {
+      state.manifest = value;
+    },
+    get fingerprint() {
+      return state.fingerprint;
+    },
+    set fingerprint(value: string) {
+      state.fingerprint = value;
+    },
+    load: async () => {
+      if (!state.manifest) {
+        return {
+          ok: false as const,
+          state: "snapshot-unavailable" as const,
+          message: "Test snapshot fixture is not initialized.",
+        };
+      }
+      return {
+        ok: true as const,
+        packageRoot: state.packageRoot,
+        snapshotRoot: state.snapshotRoot,
+        packageVersion: state.manifest.packageVersion,
+        manifest: state.manifest,
+        fingerprint: state.fingerprint,
+      };
+    },
+  };
+});
+
+vi.mock("../../src/setup/harness-workspace-snapshot-loader.js", () => ({
+  loadEmbeddedWorkspaceSnapshot: vi.fn(async () => snapshotFixture.load()),
+  loadEmbeddedWorkspaceSnapshotIdentityForStatus: vi.fn(async () =>
+    snapshotFixture.load(),
+  ),
+}));
+
+function buildManifest(readme: Buffer): WorkspaceSnapshotManifest {
+  const gitBlobSha1 = computeGitBlobSha1(readme);
+  return buildWorkspaceSnapshotManifest({
+    packageVersion: "0.3.1",
+    sourceCommit: "cccccccccccccccccccccccccccccccccccccccc",
+    entries: [
+      {
+        path: "README.md",
+        type: "file",
+        mode: "100644",
+        size: readme.byteLength,
+        content: readme,
+        gitBlobSha1,
+      },
+    ],
+  });
+}
+
+function markerJson(manifest: WorkspaceSnapshotManifest): string {
+  return `${JSON.stringify(
+    buildHarnessSnapshotManagedRepoMarker({
+      repository: REPO_SLUG,
+      repositoryId: REPO_ID,
+      manifest,
+      snapshotCommitSha: "remote-marker-commit",
+      defaultBranch: "main",
+    }),
+    null,
+    2,
+  )}\n`;
+}
+
+async function writeWorkspace(root: string): Promise<void> {
+  await mkdir(path.join(root, ".harness"), { recursive: true });
+  await writeFile(
+    path.join(root, ".env.local"),
+    [
+      "GITHUB_TOKEN=ghp_test_token",
+      `GITHUB_DISPATCH_REPOSITORY=${REPO_SLUG}`,
+      "LINEAR_API_KEY=linear-test-key",
+      "CURSOR_API_KEY=cursor-test-key",
+    ].join("\n"),
+    "utf8",
+  );
+  await writeFile(
+    path.join(root, ".harness", "config.local.json"),
+    `${JSON.stringify(
+      {
+        version: 1,
+        orchestratorMarker: "harness-orchestrator-v1",
+        logDirectory: "runs",
+        repos: [
+          {
+            id: "target-app",
+            targetRepo: "https://github.com/weston-uribe/weston-uribe-portfolio",
+            baseBranch: "main",
+            productionBranch: "main",
+          },
+        ],
+        allowedTargetRepos: [
+          "https://github.com/weston-uribe/weston-uribe-portfolio",
+        ],
+        linear: { teamKey: "FRE" },
+        roleModels: {
+          planner: { id: "composer-2.5" },
+          builder: { id: "composer-2.5" },
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}
+
+describe("release sync managed runner", () => {
+  let workspaceDir = "";
+  const v1Manifest = buildManifest(README_V1);
+  const v2Manifest = buildManifest(README_V2);
+
+  beforeEach(async () => {
+    workspaceDir = await mkdtemp(path.join(tmpdir(), "release-sync-runner-"));
+    await writeWorkspace(workspaceDir);
+    const fixture = await createTestWorkspaceSnapshotRoot("0.3.1");
+    snapshotFixture.packageRoot = fixture.packageRoot;
+    snapshotFixture.snapshotRoot = fixture.snapshotRoot;
+    snapshotFixture.manifest = v2Manifest;
+    snapshotFixture.fingerprint = fingerprintWorkspaceSnapshotManifest(v2Manifest);
+    await writeFile(
+      path.join(snapshotFixture.snapshotRoot, "manifest.json"),
+      `${JSON.stringify(v2Manifest, null, 2)}\n`,
+      "utf8",
+    );
+    await writeFile(
+      path.join(snapshotFixture.snapshotRoot, "files", "README.md"),
+      README_V2,
+    );
+  });
+
+  afterEach(async () => {
+    await rm(workspaceDir, { recursive: true, force: true });
+  });
+
+  it("blocks wrong or unmanaged repository", async () => {
+    const provider = await createMockRunnerUpgradeProvider({
+      repositories: {
+        "other/repo": {
+          repositoryId: 999,
+          owner: "other",
+          repo: "repo",
+          defaultBranch: "main",
+          remoteFiles: { "README.md": "x" },
+        },
+      },
+    });
+    await expect(
+      runReleaseSyncManagedRunner(provider, {
+        cwd: workspaceDir,
+        apply: true,
+      }),
+    ).rejects.toMatchObject({
+      name: "ReleaseSyncManagedRunnerError",
+      phase: "resolve_repository",
+    });
+  });
+
+  it("blocks unexpected main changes via three-way compare", async () => {
+    const remoteMarker = markerJson(v1Manifest);
+    const provider = await createMockRunnerUpgradeProvider({
+      repositories: {
+        [REPO_SLUG]: {
+          repositoryId: REPO_ID,
+          owner: "weston-uribe",
+          repo: "p-dev-harness",
+          defaultBranch: "main",
+          managedMarkerContent: remoteMarker,
+          remoteFiles: {
+            "README.md": "# operator edited remote\n",
+            [HARNESS_MANAGED_REPO_MARKER_FILE]: remoteMarker,
+          },
+        },
+      },
+    });
+    await expect(
+      runReleaseSyncManagedRunner(provider, {
+        cwd: workspaceDir,
+        apply: true,
+      }),
+    ).rejects.toBeInstanceOf(ReleaseSyncManagedRunnerError);
+  });
+
+  it("upgrades the known managed snapshot, syncs secret+fingerprint, requires canary, and skips Linear/Cursor/Vercel", async () => {
+    const remoteMarker = markerJson(v1Manifest);
+    const provider = await createMockRunnerUpgradeProvider({
+      canaryConclusion: "success",
+      repositories: {
+        [REPO_SLUG]: {
+          repositoryId: REPO_ID,
+          owner: "weston-uribe",
+          repo: "p-dev-harness",
+          defaultBranch: "main",
+          managedMarkerContent: remoteMarker,
+          remoteFiles: {
+            "README.md": README_V1.toString("utf8"),
+            [HARNESS_MANAGED_REPO_MARKER_FILE]: remoteMarker,
+          },
+        },
+      },
+    });
+
+    const result = await runReleaseSyncManagedRunner(provider, {
+      cwd: workspaceDir,
+      apply: true,
+    });
+    expect(result.ok).toBe(true);
+    expect(result.codeUpdateSkippedBecauseAlreadyCurrent).toBe(false);
+    expect(result.canaryRunUrl).toBeTruthy();
+    expect(provider.remoteWriteOrder).toEqual(["secret", "variable"]);
+    const dispatchCall = provider.calls.find(
+      (call) => call.method === "dispatchWorkflow",
+    );
+    expect(dispatchCall?.args[4]).toMatchObject({
+      canary_operation_id: expect.any(String),
+    });
+    // Mock simulates GitHub 204: dispatch itself returns no run id; locate by op id.
+    expect(
+      provider.calls.some((call) => call.method === "listWorkflowRuns"),
+    ).toBe(true);
+
+    const forbidden = provider.calls.filter((call) => {
+      const method = call.method.toLowerCase();
+      return (
+        method.includes("linear") ||
+        method.includes("cursor") ||
+        method.includes("vercel") ||
+        method.includes("target")
+      );
+    });
+    expect(forbidden).toHaveLength(0);
+    expect(await readRunnerUpgradePendingState(workspaceDir)).toBeNull();
+  }, 30_000);
+
+  it("fails when canary does not pass", async () => {
+    const remoteMarker = markerJson(v2Manifest);
+    const provider = await createMockRunnerUpgradeProvider({
+      canaryConclusion: "failure",
+      repositories: {
+        [REPO_SLUG]: {
+          repositoryId: REPO_ID,
+          owner: "weston-uribe",
+          repo: "p-dev-harness",
+          defaultBranch: "main",
+          managedMarkerContent: remoteMarker,
+          remoteFiles: {
+            "README.md": README_V2.toString("utf8"),
+            [HARNESS_MANAGED_REPO_MARKER_FILE]: remoteMarker,
+          },
+        },
+      },
+    });
+
+    await expect(
+      runReleaseSyncManagedRunner(provider, {
+        cwd: workspaceDir,
+        apply: true,
+      }),
+    ).rejects.toMatchObject({
+      name: "ReleaseSyncManagedRunnerError",
+      phase: "run_configuration_canary",
+    });
+    expect(provider.remoteWriteOrder).toEqual(["secret", "variable"]);
+  }, 30_000);
+
+  it("archives pending so automatic resume cannot continue", async () => {
+    await writeFile(
+      path.join(workspaceDir, ".harness", "p-dev-runner-upgrade.pending.json"),
+      `${JSON.stringify(
+        {
+          operationId: "op-archive",
+          repositoryId: REPO_ID,
+          repoSlug: REPO_SLUG,
+          defaultBranch: "main",
+          targetSnapshotContentId: v2Manifest.snapshotContentId,
+          phase: "running-configuration-canary",
+          startedAt: new Date().toISOString(),
+          previewFingerprint: "",
+          syncInProgress: false,
+          codeUpdateComplete: true,
+          lastError: "Configuration canary failed with conclusion failure.",
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+    const remoteMarker = markerJson(v2Manifest);
+    const provider = await createMockRunnerUpgradeProvider({
+      canaryConclusion: "success",
+      repositories: {
+        [REPO_SLUG]: {
+          repositoryId: REPO_ID,
+          owner: "weston-uribe",
+          repo: "p-dev-harness",
+          defaultBranch: "main",
+          managedMarkerContent: remoteMarker,
+          remoteFiles: {
+            "README.md": README_V2.toString("utf8"),
+            [HARNESS_MANAGED_REPO_MARKER_FILE]: remoteMarker,
+          },
+        },
+      },
+    });
+    const result = await runReleaseSyncManagedRunner(provider, {
+      cwd: workspaceDir,
+      apply: true,
+    });
+    expect(result.cancel?.cancelled).toBe(true);
+    expect(result.cancel?.archivedDir).toBeTruthy();
+    expect(await readRunnerUpgradePendingState(workspaceDir)).toBeNull();
+    const note = await readFile(
+      path.join(result.cancel!.archivedDir!, "CANCELLED.md"),
+      "utf8",
+    );
+    expect(note).toContain("op-archive");
+  }, 30_000);
+
+  it("keeps runner upgrade UI disabled unless feature flag is explicitly enabled", () => {
+    expect(isRunnerUpgradeUiEnabled({})).toBe(false);
+    expect(isRunnerUpgradeUiEnabled({ P_DEV_RUNNER_UPGRADE_UI_ENABLED: "0" })).toBe(
+      false,
+    );
+    expect(isRunnerUpgradeUiEnabled({ P_DEV_RUNNER_UPGRADE_UI_ENABLED: "1" })).toBe(
+      true,
+    );
+  });
+});

package/workspace-snapshot/files/tests/setup/runner-upgrade-canary.test.ts

@@ -0,0 +1,201 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { fingerprintHarnessConfigBytes } from "../../src/config/cloud-config-fingerprint.js";
+import { harnessConfigSchema } from "../../src/config/schema.js";
+import { computeGitBlobSha1 } from "../../src/p-dev/git-object-plumbing.js";
+import {
+  buildWorkspaceSnapshotManifest,
+} from "../../src/p-dev/workspace-snapshot-manifest.js";
+import { formatHarnessConfigJson } from "../../src/setup/config-builder.js";
+import {
+  buildHarnessSnapshotManagedRepoMarker,
+  HARNESS_MANAGED_REPO_MARKER_FILE,
+} from "../../src/setup/harness-managed-repo-marker.js";
+import { runRunnerConfigCanary } from "../../src/setup/runner-upgrade-canary.js";
+import {
+  buildCanaryRunName,
+  workflowRunMatchesCanaryOperationId,
+} from "../../src/setup/runner-upgrade-canary-dispatch.js";
+import { buildCanonicalCloudConfigPair } from "../../src/setup/sync-harness-config-cloud.js";
+
+const PORTFOLIO = "https://github.com/weston-uribe/weston-uribe-portfolio";
+
+function managedMarkerJson(): string {
+  const readme = Buffer.from("# canary\n", "utf8");
+  const manifest = buildWorkspaceSnapshotManifest({
+    packageVersion: "0.3.1",
+    sourceCommit: "a".repeat(40),
+    entries: [
+      {
+        path: "README.md",
+        type: "file",
+        mode: "100644",
+        size: readme.byteLength,
+        content: readme,
+        gitBlobSha1: computeGitBlobSha1(readme),
+      },
+    ],
+  });
+  return `${JSON.stringify(
+    buildHarnessSnapshotManagedRepoMarker({
+      repository: "weston-uribe/p-dev-harness",
+      repositoryId: 1_304_282_812,
+      manifest,
+      snapshotCommitSha: "c".repeat(40),
+      defaultBranch: "main",
+    }),
+    null,
+    2,
+  )}\n`;
+}
+
+function sampleConfig() {
+  return harnessConfigSchema.parse({
+    version: 1,
+    orchestratorMarker: "harness-orchestrator-v1",
+    logDirectory: "runs",
+    repos: [
+      {
+        id: "portfolio",
+        targetRepo: PORTFOLIO,
+        baseBranch: "dev",
+        linearAssociations: [
+          {
+            workspaceId: "ws-fresh",
+            teamId: "8f9c1260-364b-4d3e-9aa2-0391767d5204",
+            teamKey: "FRE",
+            teamName: "fresh p-dev linear team",
+            projectId: "63125fbb-f05a-43de-8496-c8a798e39f6b",
+            projectName: "harness",
+          },
+        ],
+      },
+    ],
+    allowedTargetRepos: [PORTFOLIO],
+    linear: {
+      teamId: "8f9c1260-364b-4d3e-9aa2-0391767d5204",
+      teamKey: "FRE",
+    },
+    roleModels: {
+      planner: { id: "composer-2.5" },
+      builder: { id: "composer-2.5" },
+    },
+  });
+}
+
+describe("runner config canary + cloud fingerprint sync", () => {
+  let dir = "";
+
+  afterEach(async () => {
+    if (dir) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("buildCanonicalCloudConfigPair uses formatHarnessConfigJson + fingerprintHarnessConfigBytes", async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "cloud-pair-"));
+    await mkdir(path.join(dir, ".harness"), { recursive: true });
+    const config = sampleConfig();
+    // Deliberately non-canonical local formatting (compact JSON, no trailing newline).
+    await writeFile(
+      path.join(dir, ".harness", "config.local.json"),
+      JSON.stringify(config),
+      "utf8",
+    );
+    const pair = await buildCanonicalCloudConfigPair(dir);
+    const expectedBytes = Buffer.from(formatHarnessConfigJson(config), "utf8");
+    expect(pair.fingerprint).toBe(fingerprintHarnessConfigBytes(expectedBytes));
+    expect(pair.encodedValue).toBe(expectedBytes.toString("base64"));
+    expect(pair.bytes.equals(expectedBytes)).toBe(true);
+  });
+
+  it("prints safe failure details for fingerprint/decode/association without secrets", async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "canary-fail-"));
+    await mkdir(path.join(dir, ".harness"), { recursive: true });
+    await writeFile(
+      path.join(dir, HARNESS_MANAGED_REPO_MARKER_FILE),
+      managedMarkerJson(),
+      "utf8",
+    );
+
+    const writes: string[] = [];
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+      return true;
+    }) as typeof process.stdout.write;
+
+    try {
+      const result = await runRunnerConfigCanary(dir, {
+        GITHUB_ACTIONS: "true",
+        HARNESS_CONFIG_JSON_B64: Buffer.from('{"version":1}', "utf8").toString(
+          "base64",
+        ),
+        HARNESS_CONFIG_FINGERPRINT: "not-the-real-hash",
+      });
+      expect(result.ok).toBe(false);
+      expect(result.expectedFingerprint).toBe("not-the-real-hash");
+      expect(result.computedFingerprint).toMatch(/^[a-f0-9]{64}$/);
+      expect(result.configDecodingSucceeded).toBe(false);
+      expect(result.associationResolutionSucceeded).toBe(false);
+      const printed = writes.join("");
+      expect(printed).toContain("expectedFingerprint");
+      expect(printed).toContain("computedFingerprint");
+      expect(printed).toContain("configDecodingSucceeded");
+      expect(printed).toContain("associationResolutionSucceeded");
+      // Never include secret payload or decoded config body.
+      expect(printed).not.toMatch(/eyJ/); // raw base64 config payload
+      expect(printed).not.toContain('"repos"');
+      expect(printed).not.toContain(PORTFOLIO);
+    } finally {
+      process.stdout.write = originalWrite;
+    }
+  });
+
+  it("passes when cloud config fingerprint, decode, and associations succeed without local config.local.json", async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "canary-ok-"));
+    await mkdir(path.join(dir, ".harness"), { recursive: true });
+    await writeFile(
+      path.join(dir, HARNESS_MANAGED_REPO_MARKER_FILE),
+      managedMarkerJson(),
+      "utf8",
+    );
+
+    const config = sampleConfig();
+    const bytes = Buffer.from(formatHarnessConfigJson(config), "utf8");
+    const b64 = bytes.toString("base64");
+    const fingerprint = fingerprintHarnessConfigBytes(bytes);
+
+    const result = await runRunnerConfigCanary(dir, {
+      GITHUB_ACTIONS: "true",
+      HARNESS_CONFIG_JSON_B64: b64,
+      HARNESS_CONFIG_FINGERPRINT: fingerprint,
+    });
+    expect(result.ok).toBe(true);
+    expect(result.cloudConfigValid).toBe(true);
+    expect(result.configDecodingSucceeded).toBe(true);
+    expect(result.associationResolutionSucceeded).toBe(true);
+    expect(result.expectedFingerprint).toBe(fingerprint);
+    expect(result.computedFingerprint).toBe(fingerprint);
+    expect(result.targetRepos[0]?.id).toBe("portfolio");
+  });
+
+  it("matches canary runs by unique operation id after dispatch 204", () => {
+    const operationId = "op-canary-1234";
+    const name = buildCanaryRunName(operationId);
+    expect(
+      workflowRunMatchesCanaryOperationId(
+        { name, displayTitle: name },
+        operationId,
+      ),
+    ).toBe(true);
+    expect(
+      workflowRunMatchesCanaryOperationId(
+        { name: "PDev runner config canary", displayTitle: "other" },
+        operationId,
+      ),
+    ).toBe(false);
+  });
+});