@mytegroupinc/myte-core 0.0.47 → 0.0.49

package/lib/certification-manifest.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const { randomUUID } = require("node:crypto");
+
+const SCHEMA_VERSION = 1;
+const ARTIFACT_KINDS = new Set([
+  "feedback",
+  "review_request",
+  "feedback_event",
+  "comment",
+  "notification",
+  "object",
+  "query_job",
+]);
+const SENSITIVE_KEY = /(api[_-]?key|authorization|bearer|password|secret|token|credential)/i;
+
+function cleanText(value, label, maxLength = 500) {
+  const text = String(value || "").trim();
+  if (!text) throw new Error(`${label} is required.`);
+  if (text.length > maxLength) throw new Error(`${label} is too long.`);
+  return text;
+}
+
+function createCertificationManifest({
+  runId = randomUUID(),
+  namespace,
+  projectId,
+  environment = "dev",
+  createdAt = new Date().toISOString(),
+} = {}) {
+  const cleanRunId = cleanText(runId, "run_id", 128);
+  const cleanNamespace = cleanText(
+    namespace || `MYTE_TEST_${cleanRunId.replace(/[^A-Za-z0-9_-]/g, "_")}`,
+    "namespace",
+    180,
+  );
+  return {
+    schema_version: SCHEMA_VERSION,
+    kind: "myte_project_assistant_certification",
+    run_id: cleanRunId,
+    namespace: cleanNamespace,
+    project_id: projectId ? cleanText(projectId, "project_id", 128) : null,
+    environment: cleanText(environment, "environment", 40),
+    created_at: createdAt,
+    updated_at: createdAt,
+    state: "planned",
+    artifacts: [],
+    checks: [],
+  };
+}
+
+function assertManifestSafe(value, path = "manifest") {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertManifestSafe(item, `${path}[${index}]`));
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, item] of Object.entries(value)) {
+    if (SENSITIVE_KEY.test(key)) {
+      throw new Error(`Sensitive field is not allowed in certification manifests: ${path}.${key}`);
+    }
+    assertManifestSafe(item, `${path}.${key}`);
+  }
+}
+
+function validateCertificationManifest(manifest, { expectedRunId } = {}) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    throw new Error("Certification manifest must be an object.");
+  }
+  if (Number(manifest.schema_version) !== SCHEMA_VERSION) {
+    throw new Error(`Unsupported certification manifest schema: ${manifest.schema_version}`);
+  }
+  if (manifest.kind !== "myte_project_assistant_certification") {
+    throw new Error("Unexpected certification manifest kind.");
+  }
+  const runId = cleanText(manifest.run_id, "run_id", 128);
+  if (expectedRunId && runId !== String(expectedRunId).trim()) {
+    throw new Error("Certification run_id does not match the requested cleanup run.");
+  }
+  cleanText(manifest.namespace, "namespace", 180);
+  if (!Array.isArray(manifest.artifacts)) {
+    throw new Error("Certification manifest artifacts must be an array.");
+  }
+  const seen = new Set();
+  for (const artifact of manifest.artifacts) {
+    if (!artifact || typeof artifact !== "object") {
+      throw new Error("Certification artifact entries must be objects.");
+    }
+    const kind = cleanText(artifact.kind, "artifact.kind", 80);
+    const id = cleanText(artifact.id, "artifact.id", 500);
+    if (!ARTIFACT_KINDS.has(kind)) {
+      throw new Error(`Unsupported certification artifact kind: ${kind}`);
+    }
+    if (String(artifact.run_id || "") !== runId) {
+      throw new Error(`Artifact ${kind}:${id} does not belong to run ${runId}.`);
+    }
+    const identity = `${kind}:${id}`;
+    if (seen.has(identity)) {
+      throw new Error(`Duplicate certification artifact: ${identity}`);
+    }
+    seen.add(identity);
+  }
+  assertManifestSafe(manifest);
+  return manifest;
+}
+
+function recordCertificationArtifact(manifest, { kind, id, metadata = {} } = {}) {
+  validateCertificationManifest(manifest);
+  const cleanKind = cleanText(kind, "artifact.kind", 80);
+  const cleanId = cleanText(id, "artifact.id", 500);
+  if (!ARTIFACT_KINDS.has(cleanKind)) {
+    throw new Error(`Unsupported certification artifact kind: ${cleanKind}`);
+  }
+  assertManifestSafe(metadata, "artifact.metadata");
+  const identity = `${cleanKind}:${cleanId}`;
+  if (manifest.artifacts.some((artifact) => `${artifact.kind}:${artifact.id}` === identity)) {
+    return manifest;
+  }
+  manifest.artifacts.push({
+    kind: cleanKind,
+    id: cleanId,
+    run_id: manifest.run_id,
+    namespace: manifest.namespace,
+    metadata: { ...metadata },
+    recorded_at: new Date().toISOString(),
+  });
+  manifest.updated_at = new Date().toISOString();
+  return manifest;
+}
+
+function buildCertificationCleanupPlan(manifest, { expectedRunId } = {}) {
+  validateCertificationManifest(manifest, { expectedRunId });
+  const actions = [];
+  for (const artifact of manifest.artifacts) {
+    if (artifact.kind === "feedback") {
+      actions.push({
+        action: "archive_feedback",
+        id: artifact.id,
+        run_id: manifest.run_id,
+        namespace: manifest.namespace,
+      });
+    } else if (artifact.kind === "review_request") {
+      actions.push({
+        action: "cancel_review_request_if_active",
+        id: artifact.id,
+        run_id: manifest.run_id,
+        namespace: manifest.namespace,
+      });
+    } else {
+      actions.push({
+        action: "retain_audit_evidence",
+        artifact_kind: artifact.kind,
+        id: artifact.id,
+        run_id: manifest.run_id,
+        namespace: manifest.namespace,
+      });
+    }
+  }
+  return {
+    schema_version: SCHEMA_VERSION,
+    dry_run: true,
+    run_id: manifest.run_id,
+    namespace: manifest.namespace,
+    project_id: manifest.project_id || null,
+    action_count: actions.length,
+    actions,
+  };
+}
+
+module.exports = {
+  ARTIFACT_KINDS,
+  SCHEMA_VERSION,
+  assertManifestSafe,
+  buildCertificationCleanupPlan,
+  createCertificationManifest,
+  recordCertificationArtifact,
+  validateCertificationManifest,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",
@@ -18,9 +18,12 @@
     "test": "node --test"
   },
   "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "undici": "6.21.3"
+  },
   "publishConfig": {
     "access": "public"
   },

package/scripts/feedback-certification-cleanup.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  buildCertificationCleanupPlan,
+  validateCertificationManifest,
+} = require("../lib/certification-manifest");
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const manifestArg = String(args.manifest || "").trim();
+  const expectedRunId = String(args["run-id"] || "").trim();
+  if (!manifestArg || !expectedRunId) {
+    throw new Error("Usage: feedback-certification-cleanup --manifest <path> --run-id <id> [--json]");
+  }
+  if (args.execute || args["confirm-live"]) {
+    throw new Error(
+      "This command is intentionally dry-run only. Execute the reviewed exact-ID actions through the live Feedback harness after deployment.",
+    );
+  }
+  const manifestPath = path.resolve(process.cwd(), manifestArg);
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  validateCertificationManifest(manifest, { expectedRunId });
+  const plan = buildCertificationCleanupPlan(manifest, { expectedRunId });
+  console.log(JSON.stringify({ ok: true, manifest_path: manifestPath, ...plan }, null, 2));
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, message: error?.message || String(error) }, null, 2));
+  process.exit(1);
+}