pi-harness-runtime 1.1.439 → 1.1.441

package/packages/logging/test/integration.test.ts

@@ -1,140 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { createServer, type Server } from "node:http";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createWebhookTransport } from "../src/transports/webhook.js";
-import {
-	getCentralShipper,
-	initCentralLogging,
-	shutdownCentralLogging,
-} from "../src/singleton.js";
-import type { LogBatch } from "../src/types.js";
-import { LOG_SCHEMA_VERSION } from "../src/types.js";
-
-const cleanup: string[] = [];
-
-afterEach(async () => {
-	await shutdownCentralLogging();
-	while (cleanup.length > 0) {
-		rmSync(cleanup.pop() as string, { recursive: true, force: true });
-	}
-});
-
-/** A tiny HTTP server that records the batches it receives. */
-async function startCollector(): Promise<{ url: string; batches: LogBatch[]; server: Server }> {
-	const batches: LogBatch[] = [];
-	const server = createServer((req, res) => {
-		const chunks: Buffer[] = [];
-		req.on("data", (chunk: Buffer) => chunks.push(chunk));
-		req.on("end", () => {
-			try {
-				batches.push(JSON.parse(Buffer.concat(chunks).toString()) as LogBatch);
-			} catch {
-				// ignore malformed bodies
-			}
-			res.writeHead(202, { "Content-Type": "application/json" });
-			res.end(JSON.stringify({ accepted: true }));
-		});
-	});
-
-	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-	const address = server.address();
-	const port = typeof address === "object" && address ? address.port : 0;
-	return { url: `http://127.0.0.1:${port}/api/logs`, batches, server };
-}
-
-describe("webhook transport", () => {
-	test("delivers a batch over HTTP", async () => {
-		const collector = await startCollector();
-		try {
-			const transport = createWebhookTransport({ url: collector.url });
-			await transport.send({
-				schemaVersion: LOG_SCHEMA_VERSION,
-				batchId: "batch-1",
-				app: "test",
-				installationId: "11111111-2222-3333-4444-555555555555",
-				hostLabel: "localhost",
-				sentAt: new Date().toISOString(),
-				records: [
-					{
-						ts: new Date().toISOString(),
-						level: "info",
-						source: "test",
-						event: "unit",
-					},
-				],
-			});
-
-			expect(collector.batches).toHaveLength(1);
-			expect(collector.batches[0].records[0].event).toBe("unit");
-		} finally {
-			collector.server.close();
-		}
-	});
-
-	test("fails loudly when the server rejects the batch", async () => {
-		const server = createServer((_req, res) => {
-			res.writeHead(500);
-			res.end("nope");
-		});
-		await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-		const address = server.address();
-		const port = typeof address === "object" && address ? address.port : 0;
-
-		try {
-			const transport = createWebhookTransport({ url: `http://127.0.0.1:${port}/api/logs` });
-			await expect(
-				transport.send({
-					schemaVersion: LOG_SCHEMA_VERSION,
-					batchId: "batch-2",
-					app: "test",
-					installationId: "11111111-2222-3333-4444-555555555555",
-					hostLabel: "localhost",
-					sentAt: new Date().toISOString(),
-					records: [
-						{
-							ts: new Date().toISOString(),
-							level: "info",
-							source: "test",
-							event: "unit",
-						},
-					],
-				}),
-			).rejects.toThrow(/HTTP 500/);
-		} finally {
-			server.close();
-		}
-	});
-});
-
-describe("initCentralLogging", () => {
-	test("ships a log record to the configured webhook", async () => {
-		const collector = await startCollector();
-		const spoolDir = mkdtempSync(join(tmpdir(), "log-central-"));
-		cleanup.push(spoolDir);
-
-		try {
-			const config = initCentralLogging({
-				env: {
-					PI_LOG_SINK: "webhook",
-					PI_LOG_WEBHOOK_URL: collector.url,
-					PI_LOG_SPOOL_DIR: spoolDir,
-					PI_LOG_LEVEL: "info",
-				},
-				keysDir: spoolDir,
-			});
-
-			expect(config?.enabled).toBe(true);
-			expect(config?.transports).toHaveLength(1);
-
-			getCentralShipper()?.info("unit", "service.central", "hello");
-			await getCentralShipper()?.flush();
-
-			expect(collector.batches).toHaveLength(1);
-			expect(collector.batches[0].records[0].event).toBe("service.central");
-		} finally {
-			collector.server.close();
-		}
-	});
-});

package/packages/logging/test/log-http.test.ts

@@ -1,246 +0,0 @@
-/**
- * The log service over a real socket.
- *
- * These tests cover the request path an agent or a client actually sees:
- * authentication, the size limit, the durable acceptance and the query.
- */
-
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { createServer, type Server } from "node:http";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	LogCredentialStore,
-	LogIndexStore,
-	LogIngestService,
-	LogOutbox,
-	createLogHttpHandler,
-	hashToken,
-} from "../src/server/index.js";
-import { LOG_SCHEMA_VERSION } from "../src/types.js";
-
-const TOKEN = "install-token-1";
-const created: string[] = [];
-const servers: Server[] = [];
-
-function tempDir(): string {
-	const dir = mkdtempSync(join(tmpdir(), "log-http-"));
-	created.push(dir);
-	return dir;
-}
-
-afterEach(() => {
-	while (servers.length > 0) servers.pop()?.close();
-	while (created.length > 0) {
-		rmSync(created.pop() as string, { recursive: true, force: true });
-	}
-});
-
-function batch(overrides: Record<string, unknown> = {}): Record<string, unknown> {
-	return {
-		schemaVersion: LOG_SCHEMA_VERSION,
-		batchId: "batch-1",
-		app: "pi-harness",
-		installationId: "11111111-2222-3333-4444-555555555555",
-		sentAt: "2026-10-24T09:00:00.000Z",
-		records: [
-			{
-				ts: "2026-10-24T09:00:00.000Z",
-				level: "error",
-				source: "harness.test",
-				event: "service.failed",
-				message: "boom",
-			},
-		],
-		...overrides,
-	};
-}
-
-async function startServer(options: { configured?: boolean } = {}): Promise<{
-	url: string;
-	outbox: LogOutbox;
-}> {
-	const dir = tempDir();
-	const credentialsPath = join(dir, "log-ingest-credentials.json");
-	if (options.configured !== false) {
-		writeFileSync(
-			credentialsPath,
-			JSON.stringify({
-				credentials: [
-					{
-						id: "laptop",
-						tenantId: "acme",
-						scopes: ["logs:write", "logs:read"],
-						tokenHash: hashToken(TOKEN),
-						createdAt: "2026-01-01T00:00:00.000Z",
-					},
-				],
-			}),
-		);
-	}
-
-	const outbox = new LogOutbox({ dir: join(dir, "outbox") });
-	const index = new LogIndexStore({ dir: join(dir, "index") });
-	const service = new LogIngestService({
-		credentials: LogCredentialStore.load({
-			path: credentialsPath,
-			env: {},
-			keysDir: join(dir, "keys"),
-		}),
-		outbox,
-		index,
-	});
-
-	const handler = createLogHttpHandler({ service, outbox, index });
-	const server = createServer((req, res) => {
-		void handler(req, res);
-	});
-	servers.push(server);
-	await new Promise<void>((resolve) => server.listen(0, resolve));
-	const address = server.address();
-	const port = typeof address === "object" && address ? address.port : 0;
-
-	return { url: `http://127.0.0.1:${port}`, outbox };
-}
-
-describe("ingest over http", () => {
-	test("refuses the write when no credential is configured", async () => {
-		const { url } = await startServer({ configured: false });
-
-		const response = await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(batch()),
-		});
-
-		expect(response.status).toBe(503);
-		const body = (await response.json()) as { code: string };
-		expect(body.code).toBe("ingest_unconfigured");
-	});
-
-	test("rejects an unknown credential", async () => {
-		const { url } = await startServer();
-
-		const response = await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: "Bearer nope" },
-			body: JSON.stringify(batch()),
-		});
-
-		expect(response.status).toBe(401);
-	});
-
-	test("accepts a valid batch and queues it durably", async () => {
-		const { url, outbox } = await startServer();
-
-		const response = await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: JSON.stringify(batch()),
-		});
-
-		expect(response.status).toBe(202);
-		const body = (await response.json()) as { accepted: number; tenantId: string; queued: boolean };
-		expect(body.accepted).toBe(1);
-		expect(body.tenantId).toBe("acme");
-		expect(body.queued).toBe(true);
-		expect(outbox.listPending()).toHaveLength(1);
-	});
-
-	test("is idempotent for the same batch", async () => {
-		const { url, outbox } = await startServer();
-
-		const send = () =>
-			fetch(`${url}/api/logs`, {
-				method: "POST",
-				headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-				body: JSON.stringify(batch()),
-			});
-
-		await send();
-		const second = await send();
-
-		expect(second.status).toBe(202);
-		expect(((await second.json()) as { duplicate: boolean }).duplicate).toBe(true);
-		expect(outbox.listPending()).toHaveLength(1);
-	});
-
-	test("rejects a malformed batch", async () => {
-		const { url } = await startServer();
-
-		const response = await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: JSON.stringify({ schemaVersion: LOG_SCHEMA_VERSION, records: [] }),
-		});
-
-		expect(response.status).toBe(400);
-	});
-
-	test("rejects invalid json", async () => {
-		const { url } = await startServer();
-
-		const response = await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: "{not json",
-		});
-
-		expect(response.status).toBe(400);
-	});
-});
-
-describe("query over http", () => {
-	test("returns the records of the caller tenant only", async () => {
-		const { url } = await startServer();
-		await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: JSON.stringify(batch()),
-		});
-
-		const response = await fetch(`${url}/api/logs/query`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: JSON.stringify({ tenantId: "someone-else" }),
-		});
-
-		expect(response.status).toBe(200);
-		const body = (await response.json()) as { entries: unknown[]; tenantId: string };
-		expect(body.tenantId).toBe("acme");
-		expect(body.entries).toHaveLength(1);
-	});
-
-	test("refuses a query without a credential", async () => {
-		const { url } = await startServer();
-
-		const response = await fetch(`${url}/api/logs/query`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({}),
-		});
-
-		expect(response.status).toBe(401);
-	});
-});
-
-describe("diagnostics over http", () => {
-	test("reports the queue depth", async () => {
-		const { url, outbox } = await startServer();
-		await fetch(`${url}/api/logs`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json", Authorization: `Bearer ${TOKEN}` },
-			body: JSON.stringify(batch()),
-		});
-
-		const response = await fetch(`${url}/api/logs/health`, {
-			headers: { Authorization: `Bearer ${TOKEN}` },
-		});
-
-		expect(response.status).toBe(200);
-		const body = (await response.json()) as { outbox: { pending: number } };
-		expect(body.outbox.pending).toBe(1);
-		expect(outbox.listPending()).toHaveLength(1);
-	});
-});

package/packages/logging/test/redact.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	isSecretKey,
-	isSensitiveValueKey,
-	redactFields,
-	redactText,
-	redactValue,
-} from "../src/redact.js";
-
-describe("redactText", () => {
-	test("replaces bearer tokens", () => {
-		const out = redactText("Authorization: Bearer abcdef0123456789xyz");
-		expect(out).not.toContain("abcdef0123456789xyz");
-		expect(out).toContain("[REDACTED]");
-	});
-
-	test("replaces api keys", () => {
-		const out = redactText("using sk-abcdefghijklmnopqrstuvwx now");
-		expect(out).not.toContain("sk-abcdefghijklmnopqrstuvwx");
-	});
-
-	test("replaces credential assignments but keeps the key name", () => {
-		const out = redactText("api_key=super-secret-value");
-		expect(out).toContain("api_key=");
-		expect(out).not.toContain("super-secret-value");
-	});
-
-	test("replaces JWTs", () => {
-		const jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dBjftJeZ4CVPmB92K27uhbUJU1p1r_wW1gFWFOEjXk";
-		expect(redactText(`token ${jwt}`)).not.toContain(jwt);
-	});
-
-	test("keeps ordinary text intact", () => {
-		expect(redactText("service started in 42ms")).toBe("service started in 42ms");
-	});
-});
-
-describe("isSecretKey", () => {
-	test("detects credential key names", () => {
-		expect(isSecretKey("apiKey")).toBe(true);
-		expect(isSecretKey("openai_api_key")).toBe(true);
-		expect(isSecretKey("authorization")).toBe(true);
-		expect(isSecretKey("r2SecretAccessKey")).toBe(true);
-		expect(isSecretKey("userId")).toBe(false);
-		expect(isSecretKey("durationMs")).toBe(false);
-	});
-});
-
-describe("isSensitiveValueKey", () => {
-	test("detects content keys", () => {
-		expect(isSensitiveValueKey("content")).toBe(true);
-		expect(isSensitiveValueKey("raw")).toBe(true);
-		expect(isSensitiveValueKey("messages")).toBe(true);
-		expect(isSensitiveValueKey("durationMs")).toBe(false);
-	});
-});
-
-describe("redactValue", () => {
-	test("redacts secret fields of an object", () => {
-		const out = redactValue({
-			user: "alice",
-			apiKey: "sk-should-not-appear",
-			nested: { password: "hunter2", ok: 1 },
-		}) as Record<string, unknown>;
-
-		expect(out.user).toBe("alice");
-		expect(out.apiKey).toBe("[REDACTED]");
-		const nested = out.nested as Record<string, unknown>;
-		expect(nested.password).toBe("[REDACTED]");
-		expect(nested.ok).toBe(1);
-	});
-
-	test("redacts sensitive content fields", () => {
-		const out = redactValue({ content: "long prompt", title: "ok" }) as Record<string, unknown>;
-		expect(out.content).toBe("[REDACTED]");
-		expect(out.title).toBe("ok");
-	});
-
-	test("truncates long strings", () => {
-		const out = redactValue("word ".repeat(1000), { maxStringLength: 100 }) as string;
-		expect(out.length).toBeLessThan(200);
-		expect(out).toContain("[truncated:");
-	});
-
-	test("limits nesting depth", () => {
-		let deep: Record<string, unknown> = { value: 1 };
-		for (let i = 0; i < 10; i++) deep = { child: deep };
-		const out = JSON.stringify(redactValue(deep, { maxDepth: 3 }));
-		expect(out).toContain("[MAX_DEPTH]");
-	});
-
-	test("converts errors into a safe shape", () => {
-		const out = redactValue(new Error("boom")) as Record<string, unknown>;
-		expect(out.name).toBe("Error");
-		expect(out.message).toBe("boom");
-	});
-});
-
-describe("redactFields", () => {
-	test("returns undefined for missing fields", () => {
-		expect(redactFields(undefined)).toBeUndefined();
-	});
-
-	test("redacts a flat bag", () => {
-		const out = redactFields({ token: "abc", count: 3 });
-		expect(out?.token).toBe("[REDACTED]");
-		expect(out?.count).toBe(3);
-	});
-});

package/packages/logging/test/sampler.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { LogSampler } from "../src/sampler.js";
-import type { LogRecord } from "../src/types.js";
-
-function record(overrides: Partial<LogRecord> = {}): LogRecord {
-	return {
-		ts: "2026-10-24T00:00:00.000Z",
-		level: "info",
-		source: "test",
-		event: "unit",
-		...overrides,
-	};
-}
-
-describe("LogSampler", () => {
-	test("drops records below the minimum level", () => {
-		const sampler = new LogSampler({ minLevel: "warn" });
-		expect(sampler.shouldLog(record({ level: "info" }))).toBe(false);
-		expect(sampler.shouldLog(record({ level: "warn" }))).toBe(true);
-	});
-
-	test("keeps errors regardless of level", () => {
-		const sampler = new LogSampler({ minLevel: "error" });
-		expect(sampler.shouldLog(record({ level: "error" }))).toBe(true);
-	});
-
-	test("applies the sample rate deterministically to debug records", () => {
-		const sampler = new LogSampler({ minLevel: "debug", sampleRate: 0 });
-		expect(sampler.shouldLog(record({ level: "debug" }))).toBe(false);
-
-		const always = new LogSampler({ minLevel: "debug", sampleRate: 1 });
-		expect(always.shouldLog(record({ level: "debug" }))).toBe(true);
-	});
-
-	test("rate limits repeated events per minute", () => {
-		const sampler = new LogSampler({ minLevel: "debug", sampleRate: 1, rateLimitPerMinute: 2 });
-		const now = 1_700_000_000_000;
-		expect(sampler.shouldLog(record({ level: "info" }), now)).toBe(true);
-		expect(sampler.shouldLog(record({ level: "info" }), now)).toBe(true);
-		expect(sampler.shouldLog(record({ level: "info" }), now)).toBe(false);
-	});
-
-	test("rate limit window rolls over", () => {
-		const sampler = new LogSampler({ minLevel: "debug", sampleRate: 1, rateLimitPerMinute: 1 });
-		const now = 1_700_000_000_000;
-		expect(sampler.shouldLog(record({ level: "info" }), now)).toBe(true);
-		expect(sampler.shouldLog(record({ level: "info" }), now + 60_000)).toBe(true);
-	});
-
-	test("errors are exempt from the rate limit", () => {
-		const sampler = new LogSampler({ minLevel: "debug", sampleRate: 1, rateLimitPerMinute: 1 });
-		const now = 1_700_000_000_000;
-		expect(sampler.shouldLog(record({ level: "info" }), now)).toBe(true);
-		expect(sampler.shouldLog(record({ level: "error" }), now)).toBe(true);
-		expect(sampler.shouldLog(record({ level: "error" }), now)).toBe(true);
-	});
-});