Files
Netcatty/electron/plugins/pluginLogger.test.cjs
T

259 lines
14 KiB
JavaScript

"use strict";
const assert = require("node:assert/strict");
const fs = require("node:fs/promises");
const os = require("node:os");
const path = require("node:path");
const test = require("node:test");
const { PluginLogger, PluginLogSink, redactLogValue } = require("./pluginLogger.cjs");
const { PluginLogService } = require("./pluginLogService.cjs");
const { PluginHostRpcRegistry } = require("./hostRpcRegistry.cjs");
const { PluginPermissionEngine } = require("./permissionEngine.cjs");
const { RPC_ERRORS } = require("./rpcRouter.cjs");
async function fixture(t, limits = {}) {
const root = await fs.mkdtemp(path.join(os.tmpdir(), "netcatty-synthetic-plugin-logs-"));
const paths = { root, logs: path.join(root, "logs") };
let response = 0;
const service = new PluginLogService({ paths, limits, resolveProvenance: () => ({ sourceId: "synthetic-source", sourceKind: "local", namespace: "test" }),
electron: { shell: { openPath: async () => "" }, dialog: { showMessageBox: async () => ({ response }), showSaveDialog: async () => ({ filePath: path.join(root, "export.jsonl") }) } } });
await service.ready;
t.after(async () => { await service.close(); await fs.rm(root, { recursive: true, force: true }); });
const identity = { pluginId: "com.example.synthetic", pluginVersion: "1.2.3", runtimeId: "host-runtime-1", runtimeKind: "browser" };
const logger = service.createLogger(identity, { archiveSha256: "a".repeat(64) });
const records = async () => {
await service.sink.flush();
const files = await fs.readdir(service.directory).catch(() => []);
const lines = (await Promise.all(files.map((name) => fs.readFile(path.join(service.directory, name), "utf8")))).join("");
return lines.trim() ? lines.trim().split("\n").map(JSON.parse) : [];
};
return { service, logger, identity, root, paths, records, confirm: () => { response = 1; } };
}
test("persistence defaults off and disabled logger does not coerce or inspect text", async (t) => {
const f = await fixture(t);
await f.logger.write("error", { toString() { throw Error("must not execute"); } });
f.logger.audit({ operation: "storage.get", result: "ok" });
assert.deepEqual(await f.records(), []);
await assert.rejects(fs.stat(f.service.directory), { code: "ENOENT" });
assert.equal(f.service.status().saveToDisk, false);
});
test("enabled host audit excludes bodies and binds host source, version, hash and runtime", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: false });
await f.logger.write("info", "SYNTHETIC_SECRET_PROMPT");
f.logger.audit({ operation: "network.request", authorization: "allowed", result: "ok", resources: ["https://user:password@example.test/private?api_key=SYNTHETIC_SECRET"],
body: "SYNTHETIC_SECRET_BODY", error: "SYNTHETIC_SECRET_ERROR", inputBytes: 24, outputBytes: 64, durationMs: 3, pluginId: "spoof" });
const records = await f.records();
assert.equal(records.length, 1);
assert.equal(records[0].pluginId, f.identity.pluginId);
assert.equal(records[0].sourceId, "synthetic-source");
assert.equal(records[0].archiveSha256, "a".repeat(64));
assert.equal(records[0].runtimeId, "host-runtime-1");
assert.equal(records[0].authorization, "allowed");
assert.equal(records[0].inputBytes, 24);
assert.match(records[0].targetIds[0], /^[a-f0-9]{64}$/u);
assert.doesNotMatch(JSON.stringify(records), /SYNTHETIC_SECRET|example.test|password|spoof/);
});
test("verbose diagnostics are opt-in, bounded and cannot impersonate host records", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: true });
await f.logger.write("bad", "message\u001b\n", { sourceId: "spoof", recordType: "host-audit", apiKey: "SYNTHETIC_SECRET", prompt: "SYNTHETIC_SECRET", Notes: "SYNTHETIC_SECRET", SQL: "SYNTHETIC_SECRET", results: "SYNTHETIC_SECRET", terminalContent: "SYNTHETIC_SECRET", credentialPayload: "SYNTHETIC_SECRET" });
const records = await f.records();
assert.equal(records[0].sourceId, "synthetic-source");
assert.equal(records[0].recordType, "plugin-diagnostic");
assert.equal(records[0].trust, "plugin-authored-unverified");
assert.equal(records[0].diagnostic.fields.sourceId, "spoof");
assert.doesNotMatch(JSON.stringify(records), /SYNTHETIC_SECRET|\\u001b/);
const cyclic = {}; cyclic.self = cyclic;
await f.logger.write("error", { toString() { throw Error("coercion"); } }, cyclic);
await f.logger.write("info", "proxy", new Proxy({}, { ownKeys() { throw Error("proxy"); } }));
const getter = {};
Object.defineProperty(getter, "value", { enumerable: true, get() { throw Error("accessor"); } });
assert.equal(redactLogValue(getter).value, "[UNAVAILABLE]");
assert.equal((await f.records()).length, 3);
const restored = new PluginLogService({ paths: f.paths });
await restored.ready;
assert.equal(restored.status().saveToDisk, true);
assert.equal(restored.status().verbose, false);
await restored.close();
});
test("shared disk cap, queue cap, retention and drop accounting", async (t) => {
const f = await fixture(t, { maxBytes: 800, maxFiles: 2, maxPendingBytes: 1600 });
await f.service.configure({ saveToDisk: true, verbose: true });
for (let i = 0; i < 10; i++) {
f.logger.audit({ operation: "storage.get", result: "ok" });
await f.service.sink.flush();
}
let files = await fs.readdir(f.service.directory);
assert.ok(files.length <= 2);
for (const name of files) assert.ok((await fs.stat(path.join(f.service.directory, name))).size <= 800);
for (let i = 0; i < 1000; i++) f.logger.audit({ operation: "storage.get", result: "ok" });
assert.ok(f.service.sink.pendingBytes <= 1600);
assert.ok(f.service.status().droppedRecords > 0);
await f.service.sink.flush();
f.logger.audit({ operation: "storage.get", result: "ok" });
assert.ok((await f.records()).some((record) => record.droppedRecords > 0));
files = await fs.readdir(f.service.directory);
const future = Date.now() + f.service.sink.retentionMs;
f.service.sink.clock = () => future;
await f.service.sink.prune();
assert.deepEqual(await fs.readdir(f.service.directory), []);
});
test("disable, revoke, clear confirmation and shutdown stop future diagnostic writes", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: true });
await f.logger.write("info", "before revoke");
await f.service.sink.flush();
f.logger.close();
await f.logger.write("info", "after revoke");
assert.equal((await f.records()).length, 1);
await f.service.clear();
assert.equal((await f.records()).length, 1);
f.confirm(); await f.service.clear();
assert.equal((await f.records()).length, 0);
const active = f.service.createLogger(f.identity, {});
await f.service.configure({ saveToDisk: false, verbose: false });
await active.write("info", "disabled");
assert.equal((await f.records()).length, 0);
await f.service.configure({ saveToDisk: true, verbose: true });
await active.write("info", "before shutdown");
await f.service.close();
await active.write("info", "after shutdown");
assert.equal((await f.records()).length, 1);
});
test("export is local and does not alter retained files", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: false });
f.logger.audit({ operation: "filesystem.stat", result: "ok", authorization: "allowed" });
await f.service.exportLogs();
const exported = await fs.readFile(path.join(f.root, "export.jsonl"), "utf8");
assert.equal(JSON.parse(exported).operation, "filesystem.stat");
assert.equal((await f.records()).length, 1);
});
test("RPC audit includes denied, malformed and public operations without error messages or bodies", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: false });
const registry = new PluginHostRpcRegistry();
const engine = new PluginPermissionEngine({ database: { listPermissionGrants: () => [] } });
t.after(() => engine.shutdown());
registry.use(engine.createMiddleware());
registry.registerRequest("synthetic.public", (params) => ({ data: params.data }), { metadata: { public: true } });
registry.registerRequest("synthetic.denied", () => { throw Error("not reached"); });
registry.registerRequest("synthetic.invalid", () => null, { validateParams() { throw new Error("SYNTHETIC_SECRET_ERROR"); } });
const routes = registry.createRoutes({ ...f.identity, logger: f.logger });
await routes.requestHandlers["synthetic.public"]({ data: "SYNTHETIC_SECRET_BODY" }, {});
await assert.rejects(routes.requestHandlers["synthetic.denied"]({}, {}), { code: RPC_ERRORS.permissionDenied });
await assert.rejects(routes.requestHandlers["synthetic.invalid"]({}, {}));
const records = await f.records();
assert.deepEqual(records.map((r) => r.authorization), ["not-required", "denied", "not-reached"]);
assert.equal(records[0].inputBytes, 21);
assert.doesNotMatch(JSON.stringify(records), /SYNTHETIC_SECRET/);
});
test("I/O failure is counted and never fails plugin execution", async (t) => {
const f = await fixture(t);
await f.service.configure({ saveToDisk: true, verbose: true });
await fs.writeFile(f.service.sink.file(0), "");
await fs.rm(f.service.sink.file(0));
await fs.symlink(path.join(f.root, "outside"), f.service.sink.file(0));
await f.logger.write("info", "synthetic");
await f.service.sink.flush();
assert.equal(f.service.status().writeErrors, 1);
assert.equal(f.service.status().droppedRecords, 1);
});
test("invalid sink limits fail early", () => {
assert.throws(() => new PluginLogSink({ directory: "/unused", maxFiles: -1 }));
const logger = new PluginLogger();
assert.doesNotThrow(() => logger.write("info", "disabled"));
});
test("unknown provenance stays unknown and a disabled restart prunes expired files", async (t) => {
const f = await fixture(t);
f.service.resolveProvenance = () => null;
const logger = f.service.createLogger({ ...f.identity, sourceId: "manifest-official-claim" }, { sourceId: "manifest-official-claim", archiveSha256: "c".repeat(64) });
await f.service.configure({ saveToDisk: true, verbose: false });
logger.audit({ operation: "storage.get", result: "ok" });
const records = await f.records();
assert.equal(records[0].sourceId, null);
assert.equal(records[0].namespace, null);
assert.doesNotMatch(JSON.stringify(records), /manifest-official-claim/);
await f.service.configure({ saveToDisk: false, verbose: false });
const expired = await fs.readFile(f.service.sink.file(0), "utf8");
await fs.writeFile(f.service.sink.file(0), expired.replace(/"timestamp":"[^"]+"/u, '"timestamp":"2000-01-01T00:00:00.000Z"'));
const restored = new PluginLogService({ paths: f.paths });
await restored.ready;
assert.equal(restored.status().saveToDisk, false);
assert.deepEqual(await fs.readdir(restored.directory), []);
await restored.close();
});
test("noisy and malformed plugin diagnostics remain bounded with visible drops", async (t) => {
const f = await fixture(t, { maxPendingBytes: 4096 });
await f.service.configure({ saveToDisk: true, verbose: true });
const wide = {};
for (let index = 0; index < 100; index++) wide[`key-${index}`] = Array(100).fill("synthetic ".repeat(100));
await f.logger.write(Symbol("invalid"), { toString() { throw Error("must not coerce"); } }, wide);
for (let index = 0; index < 1000; index++) void f.logger.write("info", "synthetic noise", { pluginId: "spoof", index });
assert.ok(f.service.sink.pendingBytes <= 4096);
assert.ok(f.service.status().droppedRecords > 0);
for (const record of await f.records()) {
assert.equal(record.pluginId, f.identity.pluginId);
assert.ok(Buffer.byteLength(JSON.stringify(record)) < 16384);
}
});
test("source resolver URLs and userinfo are not persisted as source identity", async (t) => {
const f = await fixture(t);
f.service.resolveProvenance = () => ({ sourceId: "https://user:SYNTHETIC_SECRET@example.test/source?key=SYNTHETIC_SECRET", sourceKind: "local", namespace: "user@SYNTHETIC_SECRET" });
const logger = f.service.createLogger(f.identity, {});
await f.service.configure({ saveToDisk: true, verbose: false });
logger.audit({ operation: "storage.get", result: "ok" });
const records = await f.records();
assert.equal(records[0].sourceId, null);
assert.equal(records[0].namespace, null);
assert.doesNotMatch(JSON.stringify(records), /SYNTHETIC_SECRET/);
});
test("31 days of low-volume appends never retain an active record for seven days", async (t) => {
let now = Date.UTC(2030, 0, 1);
const f = await fixture(t, { clock: () => now });
await f.service.configure({ saveToDisk: true, verbose: false });
for (let day = 0; day < 31; day++) {
now = Date.UTC(2030, 0, 1) + day * 86400000;
f.logger.audit({ operation: `synthetic.day-${day}`, authorization: "not-required", result: "ok" });
const records = await f.records();
assert.ok(records.length > 0);
for (const record of records) assert.ok(now - Date.parse(record.timestamp) < f.service.sink.retentionMs);
}
assert.doesNotMatch(JSON.stringify(await f.records()), /synthetic.day-0"/u);
});
test("export excludes an expired active segment even when its mtime is recent", async (t) => {
let now = Date.UTC(2030, 0, 1);
const f = await fixture(t, { clock: () => now });
await f.service.configure({ saveToDisk: true, verbose: false });
f.logger.audit({ operation: "synthetic.expired", result: "ok" });
await f.service.sink.flush();
now += 86400000;
f.logger.audit({ operation: "synthetic.day-one", result: "ok" });
await f.service.sink.flush();
// Appending refreshed mtime; export must use the first host record's age.
await fs.utimes(f.service.sink.file(0), new Date(now), new Date(now));
now += f.service.sink.retentionMs;
await f.service.exportLogs();
assert.equal(await fs.readFile(path.join(f.root, "export.jsonl"), "utf8"), "");
f.logger.audit({ operation: "synthetic.new-segment", result: "ok" });
await f.service.sink.flush();
await f.service.exportLogs();
const records = (await fs.readFile(path.join(f.root, "export.jsonl"), "utf8")).trim().split("\n").map(JSON.parse);
assert.equal(records.length, 1);
assert.equal(records[0].operation, "synthetic.new-segment");
});