cuonztech-agent-harness 0.7.0 → 0.8.0

package/dist/proxy/gateway.js

@@ -53,6 +53,7 @@ export function findToolNameCollisions(upstreamTools) {
 }
 export function createProxyServer(interceptor, options = {}) {
     const auditTools = options.auditTools ?? true;
+    const withPatches = options.patches ?? true;
     const instructions = interceptor.getUpstreamInstructions();
     const server = new Server({ name: "cuonztech-agent-harness-proxy", version: VERSION }, { capabilities: { tools: {} }, ...(instructions ? { instructions } : {}) });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -89,7 +90,7 @@ export function createProxyServer(interceptor, options = {}) {
             if (name === `${AUDIT_TOOL_PREFIX}get_report`) {
                 return handleGetReport(withSession, { persist: false });
             }
-            return handleGetScore(withSession);
+            return handleGetScore(withSession, { patches: withPatches });
         }
         return interceptor.interceptToolCall(name, toolArgs, extra.signal);
     });

package/dist/report-file-guard.js

@@ -2,7 +2,8 @@
 // replacing whatever is there. A mistyped path must not turn into the loss of
 // an unrelated file (the upstream's own script, a config, a spreadsheet): an
 // existing file is only replaced if it is empty or an earlier harness report.
-import { readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, statSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
 const MAX_REPORT_BYTES = 8 * 1024 * 1024;
 export function isReplaceableReportFile(path) {
     try {
@@ -47,3 +48,76 @@ export function isReservedFileName(path) {
         .split(/[\\/]+/)
         .some((segment) => /^(nul|con|prn|aux|com[1-9]|lpt[1-9])(\..*)?$/i.test(segment));
 }
+export function inspectReportForArchive(parsed) {
+    if (parsed === null || typeof parsed !== "object") {
+        return { shouldArchive: false, callsCount: 0 };
+    }
+    const obj = parsed;
+    if (typeof obj.harnessVersion !== "string") {
+        return { shouldArchive: false, callsCount: 0 };
+    }
+    // Startup placeholders or errors from earlier runs never get archived,
+    // preventing runaway file proliferation on repeated reconnects.
+    if (obj.status === "starting" || typeof obj.startupError === "string") {
+        return { shouldArchive: false, callsCount: 0 };
+    }
+    const reportObj = obj.report;
+    const calls = Array.isArray(reportObj?.calls) ? reportObj.calls : [];
+    const forensics = obj.call_forensics;
+    const timeline = Array.isArray(forensics?.timeline) ? forensics.timeline : [];
+    const callsCount = Math.max(calls.length, timeline.length);
+    const verdict = typeof obj.verdict === "string" ? obj.verdict : undefined;
+    // We archive if there is at least one recorded call or an evaluated verdict (PASS / FAIL)
+    const shouldArchive = callsCount > 0 || verdict === "PASS" || verdict === "FAIL";
+    return {
+        shouldArchive,
+        verdict,
+        callsCount,
+    };
+}
+export function computeArchiveReportPath(filePath, now = new Date()) {
+    const dir = dirname(filePath);
+    const ext = extname(filePath);
+    const name = basename(filePath, ext);
+    // ISO timestamp with colon replaced by '-' for Windows filesystem compatibility:
+    // e.g. 2026-10-30T17-25-00.123Z
+    const safeTimestamp = now.toISOString().replace(/:/g, "-");
+    let candidate = join(dir, `${name}.${safeTimestamp}${ext || ".json"}`);
+    let counter = 1;
+    while (existsSync(candidate)) {
+        candidate = join(dir, `${name}.${safeTimestamp}.${counter}${ext || ".json"}`);
+        counter++;
+    }
+    return candidate;
+}
+export function archivePreviousReportSync(filePath, now = new Date()) {
+    const info = statSync(filePath, { throwIfNoEntry: false });
+    if (!info || !info.isFile())
+        return null;
+    if (info.size === 0 || info.size > MAX_REPORT_BYTES)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const check = inspectReportForArchive(parsed);
+    if (!check.shouldArchive)
+        return null;
+    const archivePath = computeArchiveReportPath(filePath, now);
+    try {
+        renameSync(filePath, archivePath);
+    }
+    catch (err) {
+        throw new Error(`could not archive previous report file "${filePath}" to "${archivePath}": ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        archivedPath: archivePath,
+        verdict: check.verdict,
+        callsCount: check.callsCount,
+        archivedAt: now.toISOString(),
+    };
+}

package/dist/tools/handlers.js

@@ -296,7 +296,10 @@ export async function handleGetReport(args, options = {}) {
 // Resilience Score + Hardening Patches for THIS session's own audit report —
 // unlike `benchmark` mode (which scores a hardcoded scripted call sequence
 // against itself), this scores whatever the connected agent actually did.
-export function handleGetScore(args) {
+// `patches: false` (Proxy ohne gültige Lizenz): Score und Urteil unverändert, die Härtungsvorschläge
+// (Textbausteine) gehören zum Pro-Umfang und werden durch einen Hinweis ersetzt.
+export function handleGetScore(args, options = {}) {
+    const withPatches = options.patches ?? true;
     const session = getSession(args.session_id);
     if (!session) {
         return {
@@ -311,11 +314,13 @@ export function handleGetScore(args) {
     }
     const report = generateReport(session);
     const score = computeScore([report]);
-    const patches = generatePatches([report], score);
+    const patches = withPatches ? generatePatches([report], score) : [];
     const format = args.format ?? "markdown";
+    const lockedNote = "Keine gültige Lizenz: Die Härtungsvorschläge (Textbausteine) gehören zum Pro-Umfang. " +
+        "Score und Urteil sind vollständig. Lizenz: https://cuonztech.ch/agent-harness.html#audit";
     const output = format === "json"
-        ? JSON.stringify({ score, patches }, null, 2)
-        : [formatScoreReport(score), patches.length > 0 ? formatPatchReport(patches) : null]
+        ? JSON.stringify({ score, patches, ...(withPatches ? {} : { limitedByLicense: true, licenseNotice: lockedNote }) }, null, 2)
+        : [formatScoreReport(score), withPatches ? (patches.length > 0 ? formatPatchReport(patches) : null) : lockedNote]
             .filter(Boolean)
             .join("\n\n");
     return {

package/dist/ui/server.js

@@ -18,6 +18,7 @@ import { runCampaign, renderCampaignDemoBody, followupSummary } from "../campaig
 import { runBenchmark, defaultConfig } from "../benchmark/runner.js";
 import { VERSION } from "../version.js";
 import { PAGE_HTML } from "./page.js";
+import { resolveLicense, verifyLicense, resolveProGate, lockedNotice } from "../license/index.js";
 const MAX_BODY = 64 * 1024;
 const MAX_NAME = 200;
 const MAX_AGENT_RESPONSE = 10_000;
@@ -139,10 +140,15 @@ export async function startUi(options = {}) {
         }
         return file;
     };
+    let currentLicenseVerdict = resolveLicense(options.licenseKey);
+    // Nur ein ausdrücklich übergebener, gültiger Schlüssel wird in die erzeugte Agenten-Konfiguration übernommen
+    // (damit der Proxy des Agenten die Pro-Teile in den Report schreibt); aus der Umgebung stammende nie.
+    let explicitLicenseKey = options.licenseKey;
     const dossierOptions = () => ({
         customerName: session?.customerName,
         systemName: session?.systemName,
         agentResponse: session?.agentResponse,
+        licenseVerdict: currentLicenseVerdict,
     });
     // Gleiche Vorsicht wie der Proxy: erst in eine eigene Datei, dann darüber umbenennen.
     const writeReportFile = async (path, file) => {
@@ -178,7 +184,29 @@ export async function startUi(options = {}) {
             return send(res, 200, PAGE_HTML.replace("__TOKEN__", token), "text/html; charset=utf-8");
         }
         if (req.method === "GET" && url.pathname === "/api/info") {
-            return sendJson(res, 200, { version: VERSION, bundledTestsystem: bundledTestsystem(), discoveredServers: discoverMcpServers() });
+            return sendJson(res, 200, {
+                version: VERSION,
+                bundledTestsystem: bundledTestsystem(),
+                discoveredServers: discoverMcpServers(),
+                license: {
+                    valid: currentLicenseVerdict.valid,
+                    tier: currentLicenseVerdict.tier ?? "evaluation",
+                    claims: currentLicenseVerdict.claims,
+                    reason: currentLicenseVerdict.reason,
+                },
+            });
+        }
+        if (req.method === "POST" && url.pathname === "/api/license") {
+            const body = await readJson(req);
+            const key = typeof body.key === "string" ? body.key.trim() : "";
+            currentLicenseVerdict = verifyLicense(key);
+            explicitLicenseKey = key;
+            return sendJson(res, 200, {
+                valid: currentLicenseVerdict.valid,
+                tier: currentLicenseVerdict.tier ?? "evaluation",
+                claims: currentLicenseVerdict.claims,
+                reason: currentLicenseVerdict.reason,
+            });
         }
         if (req.method === "POST" && url.pathname === "/api/doctor") {
             const body = await readJson(req);
@@ -225,6 +253,7 @@ export async function startUi(options = {}) {
                 "--allow-writes",
                 "--audit-tools", "off",
                 "--report-file", reportFile,
+                ...(currentLicenseVerdict.valid && explicitLicenseKey ? ["--license", explicitLicenseKey] : []),
             ];
             const claudeCode = ["claude mcp add --scope user agent-harness --", process.execPath, ...proxyArgs].map((p, i) => (i === 0 ? p : quoteArg(p))).join(" ");
             const claudeDesktop = JSON.stringify({ mcpServers: { "agent-harness": { command: process.execPath, args: proxyArgs } } }, null, 2);
@@ -324,18 +353,24 @@ function openBrowser(url) {
 }
 export async function runUiMode(argv) {
     if (argv.includes("--help") || argv.includes("-h")) {
-        process.stdout.write("Nutzung: ui [--port <n>] [--no-open]\n\n" +
+        process.stdout.write("Nutzung: ui [--port <n>] [--no-open] [--license <key>]\n\n" +
             "Startet die geführte Oberfläche im Browser (nur auf diesem Rechner, mit Zufalls-Schlüssel im Link).\n" +
-            "  --port <n>   feste Port-Nummer (Standard: ein freier Port)\n" +
-            "  --no-open    den Browser nicht automatisch öffnen\n");
+            "Die Oberfläche gehört zum Pro-Umfang und braucht einen gültigen Lizenzschlüssel (oder AGENT_AUDIT_LICENSE).\n" +
+            "  --port <n>      feste Port-Nummer (Standard: ein freier Port)\n" +
+            "  --no-open       den Browser nicht automatisch öffnen\n" +
+            "  --license <key> CuonzTech Agent Audit Pro Lizenzschlüssel (oder Umgebungsvariable AGENT_AUDIT_LICENSE)\n");
         return 0;
     }
     let port;
     let open = true;
+    let licenseKey;
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         if (token === "--no-open")
             open = false;
+        else if (token === "--license") {
+            licenseKey = argv[++i] ?? "";
+        }
         else if (token === "--port") {
             if (port !== undefined) {
                 process.stderr.write("Error: option --port was given more than once.\n");
@@ -353,7 +388,14 @@ export async function runUiMode(argv) {
             return 1;
         }
     }
-    const handle = await startUi({ port, open });
+    // Pro-Umfang: ohne gültige Lizenz startet die Oberfläche nicht (klarer Hinweis, Exit 1 wie jeder nicht ausgeführte Befehl).
+    // Das Frei-Paket bleibt über die Kommandozeile vollständig nutzbar (proxy, doctor, report).
+    const gate = resolveProGate(licenseKey);
+    if (!gate.pro) {
+        process.stderr.write(lockedNotice("ui", gate.verdict));
+        return 1;
+    }
+    const handle = await startUi({ port, open, licenseKey });
     process.stdout.write(`Oberfläche: ${handle.url}\n`);
     process.stdout.write("Läuft nur auf diesem Rechner. Beenden mit Strg+C.\n");
     await new Promise((ok) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuonztech-agent-harness",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "mcpName": "io.github.cuonztech/agent-harness",
   "description": "Chaos-Proxy für MCP-Server: injiziert F1-F5-Fehlerszenarien (Ghost-Write nach Timeout, 429, defektes JSON, Duplicate Dispatch, 500) vor einem echten Upstream-MCP-Server und prüft, ob ein Agent Schreibvorgänge doppelt ausführt. Mit Resilience Score und System-Prompt-Patches für beobachtetes Fehlverhalten.",
   "type": "module",
@@ -31,7 +31,7 @@
     "cuonztech"
   ],
   "author": "CuonzTech",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cuonztech/agent-harness.git"
@@ -49,6 +49,7 @@
     "examples/testsystem/server.mjs",
     "README.md",
     "LICENSE",
+    "LICENSE-MIT-bis-0.7.0.txt",
     "server.json"
   ],
   "dependencies": {

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/cuonztech/agent-harness",
     "source": "github"
   },
-  "version": "0.7.0",
+  "version": "0.8.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "cuonztech-agent-harness",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "transport": {
         "type": "stdio"
       }