@amityco/social-plus-vise 1.4.6 → 1.6.0

package/dist/tools/smoke.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { objectInput, optionalStringField, stringField, textResult } from "../types.js";
 function escapeRegExp(s) {
@@ -66,6 +67,31 @@ async function loadSmokeConfig(repoRoot) {
         return null;
     }
 }
+const RUNTIME_PROOF_WAIVER_PATH = ["sp-vise", "evidence", "runtime-proof-waiver.json"];
+export const MIN_WAIVER_REASON_CHARS = 8;
+export async function readRuntimeProofWaiver(repoRoot) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(path.join(repoRoot, ...RUNTIME_PROOF_WAIVER_PATH), "utf8"));
+        if ((parsed.mode !== "declined" && parsed.mode !== "deviceless") || typeof parsed.reason !== "string" || parsed.reason.trim().length < MIN_WAIVER_REASON_CHARS) {
+            return null;
+        }
+        return { mode: parsed.mode, reason: parsed.reason.trim(), recorded_at: typeof parsed.recorded_at === "string" ? parsed.recorded_at : "" };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeRuntimeProofWaiver(repoRoot, mode, reason, recordedAt) {
+    const trimmed = reason.trim();
+    if (trimmed.length < MIN_WAIVER_REASON_CHARS) {
+        throw new Error(`A runtime-proof waiver requires an auditable reason of at least ${MIN_WAIVER_REASON_CHARS} characters (got ${trimmed.length}).`);
+    }
+    const waiver = { mode, reason: trimmed, recorded_at: recordedAt };
+    const target = path.join(repoRoot, ...RUNTIME_PROOF_WAIVER_PATH);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, `${JSON.stringify(waiver, null, 2)}\n`, "utf8");
+    return waiver;
+}
 function smokeCaptureHelp() {
     return [
         "Create `sp-vise/smoke.json` with the mounted collection surfaces, for example `{ \"platform\": \"android\", \"surfaces\": [{ \"id\": \"feed\", \"expect\": \"populated\" }] }`.",
@@ -75,6 +101,115 @@ function smokeCaptureHelp() {
         "Then run `vise smoke . --log sp-vise/evidence/runtime-smoke.log` and rerun `vise check --ci`.",
     ].join(" ");
 }
+function digestText(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function pathInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function repoRelativePath(repoRoot, filePath) {
+    return path.relative(repoRoot, filePath).split(path.sep).join(path.posix.sep);
+}
+function shouldSkipDir(name) {
+    return new Set([
+        ".git",
+        ".idea",
+        ".vscode",
+        "node_modules",
+        "dist",
+        "build",
+        ".next",
+        ".nuxt",
+        ".dart_tool",
+        ".gradle",
+        "Pods",
+        "DerivedData",
+        "sp-vise",
+    ]).has(name);
+}
+function isSourceFile(filePath) {
+    return /\.(?:ts|tsx|js|jsx|mjs|cjs|swift|kt|kts|java|dart)$/i.test(filePath);
+}
+async function collectSourceFiles(root, limit = 800) {
+    const found = [];
+    async function walk(dir) {
+        if (found.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (found.length >= limit)
+                break;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!shouldSkipDir(entry.name))
+                    await walk(full);
+            }
+            else if (entry.isFile() && isSourceFile(full)) {
+                found.push(full);
+            }
+        }
+    }
+    await walk(root);
+    return found;
+}
+export function hasExecutableSmokeMarker(content) {
+    for (const line of content.split(/\r?\n/)) {
+        const idx = line.indexOf("VISE_SMOKE");
+        if (idx < 0)
+            continue;
+        if (/^\s*(\/\/|\*|#|<!--|\/\*)/.test(line))
+            continue;
+        const before = line.slice(0, idx);
+        if ((before.match(/["'`]/g) || []).length % 2 === 1)
+            return true;
+    }
+    return false;
+}
+async function collectSmokeSourceProvenance(repoRoot, surfaces) {
+    const files = await collectSourceFiles(repoRoot);
+    const markerFiles = [];
+    const surfaceFiles = new Map();
+    for (const file of files) {
+        let content;
+        try {
+            content = await fs.readFile(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!hasExecutableSmokeMarker(content)) {
+            continue;
+        }
+        const matchedSurfaces = surfaces
+            .map((surface) => surface.id)
+            .filter((id) => content.includes(id));
+        if (matchedSurfaces.length === 0) {
+            continue;
+        }
+        const relative = repoRelativePath(repoRoot, file);
+        markerFiles.push({
+            path: relative,
+            sha256: digestText(content),
+            surfaces: matchedSurfaces.sort(),
+        });
+        for (const surface of matchedSurfaces) {
+            surfaceFiles.set(surface, [...(surfaceFiles.get(surface) ?? []), relative]);
+        }
+    }
+    const surfaceEmitters = surfaces.map((surface) => ({
+        surface: surface.id,
+        files: (surfaceFiles.get(surface.id) ?? []).sort(),
+    }));
+    const missingSurfaces = surfaceEmitters.filter((item) => item.files.length === 0).map((item) => item.surface);
+    return { fingerprints: markerFiles.sort((a, b) => a.path.localeCompare(b.path)), surfaceEmitters, missingSurfaces };
+}
 export const smokeTool = {
     name: "smoke",
     description: "Assess a captured runtime mount-smoke log (VISE_SMOKE markers) into a pass/fail verdict and record runtime-smoke evidence. Catches the session-establish race that static check cannot.",
@@ -115,10 +250,43 @@ export const smokeTool = {
             return textResult({ status: "no-surfaces", note: only ? `Surface '${only}' is not declared in smoke.json.` : "smoke.json declares no surfaces." });
         }
         const assessment = assessSmokeLog(logText, surfaces);
+        const sourceProvenance = await collectSmokeSourceProvenance(repoRoot, surfaces);
+        if (sourceProvenance.fingerprints.length === 0 || sourceProvenance.missingSurfaces.length > 0) {
+            return textResult({
+                status: "no-source-provenance",
+                platform: config.platform,
+                results: assessment.results,
+                missingSurfaces: sourceProvenance.missingSurfaces,
+                note: "Runtime smoke log markers were not bound to source emitters. Add `VISE_SMOKE` marker code in product source for each declared surface id, rerun the app, capture logs, and rerun `vise smoke`.",
+            });
+        }
         try {
             const evidenceDir = path.join(repoRoot, "sp-vise", "evidence");
             await fs.mkdir(evidenceDir, { recursive: true });
-            await fs.writeFile(path.join(evidenceDir, "runtime-smoke.json"), JSON.stringify({ passed: assessment.passed, platform: config.platform, results: assessment.results }, null, 2));
+            const canonicalLogPath = path.join(evidenceDir, "runtime-smoke.log");
+            if (path.resolve(logPath) !== canonicalLogPath) {
+                await fs.writeFile(canonicalLogPath, logText, "utf8");
+            }
+            const smokeConfigPath = path.join(repoRoot, "sp-vise", "smoke.json");
+            const smokeConfigText = await fs.readFile(smokeConfigPath, "utf8");
+            const inputLogPath = pathInside(repoRoot, logPath) ? repoRelativePath(repoRoot, logPath) : logPath;
+            await fs.writeFile(path.join(evidenceDir, "runtime-smoke.json"), JSON.stringify({
+                passed: assessment.passed,
+                platform: config.platform,
+                generated_at: new Date().toISOString(),
+                log: {
+                    path: "sp-vise/evidence/runtime-smoke.log",
+                    input_path: inputLogPath,
+                    sha256: digestText(logText),
+                },
+                smoke_config: {
+                    path: "sp-vise/smoke.json",
+                    sha256: digestText(smokeConfigText),
+                },
+                source_fingerprints: sourceProvenance.fingerprints,
+                surface_emitters: sourceProvenance.surfaceEmitters,
+                results: assessment.results,
+            }, null, 2));
         }
         catch {
         }