@mytegroupinc/myte-core 0.0.53 → 0.0.55

package/scripts/project-assistant-live-full-harness.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { randomUUID } = require("node:crypto");
+const { spawn, spawnSync } = require("node:child_process");
+
+const ROOT = path.resolve(__dirname, "..");
+const CLI = path.join(ROOT, "cli.js");
+const ROUTES = [
+  "POST /query", "GET /query/<job_id>", "GET /config", "GET /bootstrap",
+  "GET /qaqc-sync", "POST /run-qaqc", "GET /run-qaqc/<batch_id>",
+  "POST /mission-status-update", "POST /mission-archive", "GET /feedback-sync",
+  "GET /feedback/<feedback_id>", "POST /feedback/<feedback_id>/refinement/validate",
+  "POST /feedback/<feedback_id>/refinement/requests",
+  "POST /feedback-review-requests/<request_id>/revise",
+  "POST /feedback/<feedback_id>/refinement/apply",
+  "GET /feedback/<feedback_id>/refinement/history", "GET /feedback-review-requests",
+  "GET /feedback-review-requests/<request_id>",
+  "POST /feedback-review-requests/<request_id>/review",
+  "POST /feedback-review-requests/batch-review",
+  "POST /feedback-review-requests/<request_id>/request-changes",
+  "POST /feedback-review-requests/<request_id>/cancel",
+  "POST /feedback/<feedback_id>/board-move", "POST /feedback/batch-board-move",
+  "POST /feedback/<feedback_id>/comments", "GET /feedback/<feedback_id>/events",
+  "POST /feedback/<feedback_id>/events/<event_id>/undo",
+  "GET /feedback/<feedback_id>/prd/versions",
+  "GET /feedback/<feedback_id>/prd/versions/<version_id>/diff",
+  "POST /project-comment", "POST /update-owner", "POST /client-update-drafts",
+  "POST /create-prd", "POST /create-prds", "GET /suggestions", "POST /suggestions",
+  "POST /suggestions/revise", "POST /suggestions/review",
+];
+
+const COVERAGE = {
+  read: ROUTES.filter((route) => route.startsWith("GET ") || route.startsWith("POST /query")),
+  mission: ROUTES.filter((route) => /mission|qaqc|suggestion/.test(route)),
+  feedback: ROUTES.filter((route) => /feedback|create-prd/.test(route)),
+  communications: ROUTES.filter((route) => /project-comment|update-owner|client-update/.test(route)),
+};
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) args[token.slice(2)] = true;
+    else { args[token.slice(2)] = next; index += 1; }
+  }
+  return args;
+}
+
+function routeCoverage() {
+  const accounted = new Set(Object.values(COVERAGE).flat());
+  const missing = ROUTES.filter((route) => !accounted.has(route));
+  if (ROUTES.length !== 38 || new Set(ROUTES).size !== 38 || missing.length) {
+    throw new Error(`Route manifest is incomplete: ${missing.join(", ") || "count/duplicate mismatch"}`);
+  }
+  return { implemented_project_key_routes: 38, accounted_routes: accounted.size, missing };
+}
+
+function runNode(script, args, cwd) {
+  const result = spawnSync(process.execPath, [script, ...args], {
+    cwd, env: process.env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 1_800_000,
+  });
+  let output = null;
+  try { output = JSON.parse(String(result.stdout || "").trim() || "null"); } catch {}
+  return {
+    command: path.basename(script), ok: result.status === 0,
+    exit_code: result.status, output,
+    error: result.status === 0 ? null : String(result.stderr || result.stdout || "failed").trim().slice(0, 2000),
+  };
+}
+
+function runCli(args, cwd) {
+  return runNode(CLI, args, cwd);
+}
+
+function runNodeAsync(script, args, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [script, ...args], { cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => { stdout += chunk; });
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.on("close", (code) => {
+      let output = null;
+      try { output = JSON.parse(stdout.trim() || "null"); } catch {}
+      resolve({ ok: code === 0, exit_code: code, output, error: code === 0 ? null : (stderr || stdout).trim().slice(0, 2000) });
+    });
+  });
+}
+
+async function assertExpectedProject(baseUrl, expectedProject) {
+  const key = process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY;
+  if (!key) throw new Error("Missing MYTE_API_KEY or MYTE_PROJECT_API_KEY.");
+  const response = await fetch(`${String(baseUrl).replace(/\/+$/, "")}/project-assistant/bootstrap`, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+  const body = await response.json();
+  const title = String(body?.data?.project?.title || "").trim();
+  if (!response.ok || body?.status !== "success") throw new Error("Project bootstrap preflight failed.");
+  if (title.toLowerCase() !== String(expectedProject).trim().toLowerCase()) {
+    throw new Error(`Live target mismatch: expected ${expectedProject}, received ${title || "unknown"}.`);
+  }
+  return { project_id: body.data.project.id, title };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const coverage = routeCoverage();
+  if (!args["confirm-live"]) {
+    console.log(JSON.stringify({
+      ok: true, dry_run: true, network_requests: 0, live_mutations: 0, coverage,
+      stages: ["read", "mission", "feedback", "communications", "concurrent-idempotency", "exact-id-cleanup"],
+      required_live_flags: ["--confirm-live", "--expected-project GaahField", "--include-communications"],
+      owner_email_requires: "--include-owner-email",
+    }, null, 2));
+    return;
+  }
+  const expectedProject = String(args["expected-project"] || "").trim();
+  if (expectedProject !== "GaahField") throw new Error("Live certification is pinned to --expected-project GaahField.");
+  if (!args["include-communications"]) throw new Error("Full live certification requires --include-communications.");
+  const baseUrl = String(args["base-url"] || process.env.MYTE_API_BASE || "https://api.myte.dev").replace(/\/+$/, "");
+  const project = await assertExpectedProject(baseUrl, expectedProject);
+  const runId = String(args["run-id"] || randomUUID());
+  const workspace = path.resolve(args.workspace || fs.mkdtempSync(path.join(os.tmpdir(), `myte-full-${runId}-`)));
+  fs.mkdirSync(workspace, { recursive: true });
+  const common = ["--base-url", baseUrl, "--run-id", runId];
+  const results = [];
+  results.push(runNode(path.join(__dirname, "project-assistant-read-certification.js"), ["--confirm-read", "--include-query", ...common], workspace));
+  results.push(runNode(path.join(__dirname, "mission-live-full-harness.js"), ["--confirm-live", ...common], workspace));
+  results.push(runNode(path.join(__dirname, "feedback-live-full-harness.js"), ["--confirm-live", ...common], workspace));
+
+  const team = path.join(workspace, `team-${runId}.md`);
+  const client = path.join(workspace, `client-${runId}.md`);
+  fs.writeFileSync(team, `Project Assistant certification ${runId}: team update route verified.\n`, "utf8");
+  fs.writeFileSync(client, `Project Assistant certification ${runId}: client draft route verified; do not send.\n`, "utf8");
+  const teamArgs = ["update-team", `Certification ${runId}`, "--confirm-write", "--approval-artifact", team, "--idempotency-key", `cert-team-${runId}`, "--json", "--base-url", baseUrl];
+  const concurrentTeam = await Promise.all(Array.from({ length: 10 }, () => runNodeAsync(CLI, teamArgs, workspace)));
+  const teamFingerprints = new Set(
+    concurrentTeam.filter((item) => item.ok).map((item) => JSON.stringify(item.output?.data || item.output || null)),
+  );
+  results.push({
+    command: "concurrent-idempotency:update-team",
+    ok: concurrentTeam.every((item) => item.ok) && teamFingerprints.size === 1,
+    attempts: concurrentTeam.length,
+    unique_outcomes: teamFingerprints.size,
+    error: concurrentTeam.find((item) => !item.ok)?.error || (teamFingerprints.size === 1 ? null : "Concurrent replays returned different mutation outcomes."),
+  });
+  results.push(runCli(["update-client", "--subject", `Certification ${runId}`, "--body-file", client, "--confirm-write", "--approval-artifact", client, "--idempotency-key", `cert-client-${runId}`, "--json", "--base-url", baseUrl], workspace));
+  if (args["include-owner-email"]) {
+    const owner = path.join(workspace, `owner-${runId}.md`);
+    fs.writeFileSync(owner, `Project Assistant certification ${runId}: owner delivery route verified.\n`, "utf8");
+    results.push(runCli(["update-owner", "--subject", `Certification ${runId}`, "--body-file", owner, "--confirm-write", "--approval-artifact", owner, "--idempotency-key", `cert-owner-${runId}`, "--json", "--base-url", baseUrl], workspace));
+  }
+  const failed = results.filter((result) => !result.ok);
+  const report = { ok: failed.length === 0, run_id: runId, project, coverage, workspace, results, failed_count: failed.length };
+  const reportPath = path.join(workspace, `project-assistant-certification-${runId}.json`);
+  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf8");
+  console.log(JSON.stringify({ ...report, report_path: reportPath }, null, 2));
+  if (failed.length) process.exitCode = 1;
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(JSON.stringify({ ok: false, message: error?.message || String(error) }, null, 2));
+    process.exit(1);
+  });
+} else {
+  module.exports = { COVERAGE, ROUTES, routeCoverage };
+}