pi-lean-dimension 0.5.0 → 0.6.0

package/node_modules/pi-lean-host/__tests__/smoke.test.ts

@@ -2,11 +2,10 @@
  * Smoke tests.
  *
  * Verifies the extension loads without throwing and vendored primitives
- * work as expected.
+ * work as expected. (ssrfGuard unit tests live in ssrf-guard.test.ts.)
  */
 
 import { describe, it, expect } from "vitest";
-import { ssrfGuard } from "../core/ssrf-guard.js";
 import { buildDomainMap, type Guide } from "../core/guide-loader.js";
 
 // ─── index.ts loads without throwing ─────────────────────────────
@@ -20,86 +19,6 @@ describe("extension smoke", () => {
 	}, 120_000); // the full extension import is slow under host load
 });
 
-// ─── ssrfGuard ───────────────────────────────────────────────────
-
-describe("ssrfGuard", () => {
-	function expectRejected(raw: string): void {
-		const result = ssrfGuard(raw);
-		expect(result.ok).toBe(false);
-		const r = result as { ok: false; reason: string };
-		expect(r.reason).toBeTruthy();
-	}
-
-	it("rejects AWS metadata endpoint", () => {
-		const result = ssrfGuard("http://169.254.169.254/latest/meta-data/");
-		expect(result.ok).toBe(false);
-		expect((result as { ok: false; reason: string }).reason).toContain(
-			"169.254.169.254",
-		);
-	});
-
-	it("rejects private IP 10.x.x.x", () => {
-		const result = ssrfGuard("http://10.0.0.1/admin");
-		expect(result.ok).toBe(false);
-		expect((result as { ok: false; reason: string }).reason).toContain(
-			"internal network",
-		);
-	});
-
-	it("rejects 127.0.0.1 (loopback)", () => {
-		expectRejected("http://127.0.0.1/");
-	});
-
-	it("rejects any 127.0.0.0/8 loopback (not just .1)", () => {
-		expectRejected("http://127.0.0.2/");
-		expectRejected("http://127.255.255.254/");
-	});
-
-	it("rejects link-local 169.254.0.0/16 (not just metadata IP)", () => {
-		expectRejected("http://169.254.169.253/");
-	});
-
-	it("rejects IPv6 loopback ::1 exactly", () => {
-		expectRejected("http://[::1]/");
-	});
-
-	it("allows public IPv6 that merely contains ::1 mid-string", () => {
-		expect(ssrfGuard("http://[2001:db8::1:2:3]/").ok).toBe(true);
-	});
-
-	it("allows public IPv6 that merely contains ::ffff: mid-string", () => {
-		expect(ssrfGuard("http://[2001:db8::ffff:1]/").ok).toBe(true);
-	});
-
-	it("rejects IPv6 link-local fe80::/10 and unique-local fc00::/7", () => {
-		expectRejected("http://[fe80::1]/");
-		expectRejected("http://[febf::1]/");
-		expectRejected("http://[fc00::1]/");
-		expectRejected("http://[fd12:3456::1]/");
-	});
-
-	it("rejects 192.168.x.x (private network)", () => {
-		expectRejected("http://192.168.1.1/");
-	});
-
-	it("rejects metadata.google.internal", () => {
-		expectRejected("http://metadata.google.internal/");
-	});
-
-	it("allows a legitimate public API URL", () => {
-		const result = ssrfGuard("https://apidatos.boe.es/v1/diario/20260717");
-		expect(result.ok).toBe(true);
-	});
-
-	it("rejects malformed URL", () => {
-		const result = ssrfGuard("not a url at all");
-		expect(result.ok).toBe(false);
-		expect((result as { ok: false; reason: string }).reason).toBe(
-			"Malformed URL",
-		);
-	});
-});
-
 // ─── buildDomainMap ──────────────────────────────────────────────
 
 describe("buildDomainMap", () => {

package/node_modules/pi-lean-host/__tests__/ssrf-guard.test.ts

@@ -0,0 +1,98 @@
+/**
+ * ssrfGuard (core/ssrf-guard.ts) unit tests — consolidated here from
+ * helpers.test.ts and smoke.test.ts. Pure function: no server, no fixtures.
+ */
+
+import { describe, it, expect } from "vitest";
+import { ssrfGuard } from "../core/ssrf-guard.js";
+
+function expectRejected(raw: string): void {
+	const result = ssrfGuard(raw);
+	expect(result.ok).toBe(false);
+	const r = result as { ok: false; reason: string };
+	expect(r.reason).toBeTruthy();
+}
+
+describe("ssrfGuard — IPv4-mapped IPv6 (M1)", () => {
+	it("blocks IPv4-mapped loopback in hex form", () => {
+		// Node renders http://[::ffff:127.0.0.1]/ as "[::ffff:7f00:1]" —
+		// the old decimal "::ffff:127" check never matched this.
+		expect(ssrfGuard("http://[::ffff:127.0.0.1]/").ok).toBe(false);
+	});
+
+	it("blocks IPv4-mapped private + metadata ranges", () => {
+		expect(ssrfGuard("http://[::ffff:10.0.0.1]/").ok).toBe(false);
+		expect(ssrfGuard("http://[::ffff:192.168.1.1]/").ok).toBe(false);
+		expect(ssrfGuard("http://[::ffff:169.254.169.254]/").ok).toBe(false);
+	});
+
+	it("allows public hostnames", () => {
+		expect(ssrfGuard("https://api.example.com/v1/foo").ok).toBe(true);
+		expect(ssrfGuard("https://apidatos.boe.es/v1/diario/20260717").ok).toBe(true);
+	});
+});
+
+describe("ssrfGuard — baseline blocks", () => {
+	it("rejects AWS metadata endpoint with the host named in the reason", () => {
+		const result = ssrfGuard("http://169.254.169.254/latest/meta-data/");
+		expect(result.ok).toBe(false);
+		expect((result as { ok: false; reason: string }).reason).toContain(
+			"169.254.169.254",
+		);
+	});
+
+	it("rejects private IP 10.x.x.x with an internal-network reason", () => {
+		const result = ssrfGuard("http://10.0.0.1/admin");
+		expect(result.ok).toBe(false);
+		expect((result as { ok: false; reason: string }).reason).toContain(
+			"internal network",
+		);
+	});
+
+	it("still blocks plain IPv4 private/metadata/loopback", () => {
+		expect(ssrfGuard("http://127.0.0.1/").ok).toBe(false);
+		expect(ssrfGuard("http://10.0.0.1/").ok).toBe(false);
+		expect(ssrfGuard("http://169.254.169.254/").ok).toBe(false);
+		expect(ssrfGuard("http://192.168.1.1/").ok).toBe(false);
+	});
+
+	it("rejects any 127.0.0.0/8 loopback (not just .1)", () => {
+		expectRejected("http://127.0.0.2/");
+		expectRejected("http://127.255.255.254/");
+	});
+
+	it("rejects link-local 169.254.0.0/16 (not just the metadata IP)", () => {
+		expectRejected("http://169.254.169.253/");
+	});
+
+	it("rejects IPv6 loopback ::1 exactly", () => {
+		expectRejected("http://[::1]/");
+	});
+
+	it("allows public IPv6 that merely contains ::1 mid-string", () => {
+		expect(ssrfGuard("http://[2001:db8::1:2:3]/").ok).toBe(true);
+	});
+
+	it("allows public IPv6 that merely contains ::ffff: mid-string", () => {
+		expect(ssrfGuard("http://[2001:db8::ffff:1]/").ok).toBe(true);
+	});
+
+	it("rejects IPv6 link-local fe80::/10 and unique-local fc00::/7", () => {
+		expectRejected("http://[fe80::1]/");
+		expectRejected("http://[febf::1]/");
+		expectRejected("http://[fc00::1]/");
+		expectRejected("http://[fd12:3456::1]/");
+	});
+
+	it("rejects metadata.google.internal", () => {
+		expectRejected("http://metadata.google.internal/");
+	});
+
+	it("rejects malformed URL", () => {
+		const result = ssrfGuard("not a url at all");
+		expect(result.ok).toBe(false);
+		expect((result as { ok: false; reason: string }).reason).toBe(
+			"Malformed URL",
+		);
+	});
+});

package/node_modules/pi-lean-host/__tests__/test-utils.ts

@@ -4,6 +4,41 @@
  */
 
 import { vi } from "vitest";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadApiGuidesFromDir } from "../core/guide-catalog.js";
+import { setUserGuidesDir, invalidateCache } from "../core/guide-store.js";
+import type { ApiGuide, Operation } from "../core/api-guide-types.js";
+
+/**
+ * Minimal UI mock context. `notify` is always a captured vi.fn; `input`/
+ * `confirm` are present as async vi.fn defaults — every command handler
+ * awaits them, so the superset base works for all command tests.
+ */
+export function mockCtx(overrides: Record<string, unknown> = {}): any {
+	return {
+		hasUI: true,
+		ui: {
+			input: vi.fn(async () => undefined),
+			confirm: vi.fn(async () => true),
+			notify: vi.fn(),
+		},
+		...overrides,
+	};
+}
+
+/** Collect a mock ctx's notify() calls as one newline-joined string. */
+export function notifyText(ctx: any): string {
+	return ctx.ui.notify.mock.calls.map((c: unknown[]) => c[0]).join("\n");
+}
+
+/** Extract the handler registered for a command via registerCommand. */
+export function captureApiHandler(
+	pi: ExtensionAPI,
+): (args: string, ctx: any) => Promise<void> {
+	return (pi.registerCommand as any).mock.calls[0][1].handler;
+}
 
 /** Stub global fetch as a token-endpoint mock; returns the underlying vi.fn. */
 export function stubTokenEndpoint(
@@ -29,3 +64,41 @@ export const mockTheme = {
 	fg: (_style: string, text: string) => text,
 	bold: (s: string) => s,
 } as any;
+
+/**
+ * Copy guide files from the api-guides tree into a fresh tmp guides dir under
+ * `tmpBase` (one subdir per name), point the guide store at it, and load.
+ * `guidesRoot` is the URL of the dir whose subdirs are named by `names`
+ * (co-located tests pass `new URL("../", import.meta.url)`). `files` defaults
+ * to ["guide.md"]; add "helper.ts" etc. for recipes with sibling files.
+ * Returns `{ guides }` — loaded guides keyed by directory name.
+ */
+export function stageGuides(
+	tmpBase: string,
+	guidesRoot: URL,
+	names: readonly string[],
+	files: readonly string[] = ["guide.md"],
+): { guides: Record<string, ApiGuide> } {
+	const guidesDir = mkdtempSync(join(tmpBase, "guides-"));
+	for (const name of names) {
+		mkdirSync(join(guidesDir, name), { recursive: true });
+		for (const file of files) {
+			writeFileSync(
+				join(guidesDir, name, file),
+				readFileSync(new URL(`${name}/${file}`, guidesRoot), "utf-8"),
+			);
+		}
+	}
+	setUserGuidesDir(guidesDir);
+	invalidateCache();
+	return {
+		guides: loadApiGuidesFromDir(guidesDir).guides as Record<string, ApiGuide>,
+	};
+}
+
+/** Get an op by name from a loaded guide; throws naming the missing op. */
+export function findOp(guide: ApiGuide, name: string): Operation {
+	const op = guide.operations.find((o) => o.name === name);
+	if (!op) throw new Error(`op ${name} not found`);
+	return op;
+}