pi-hypercharm-provider 1.3.27 → 1.3.29

package/tests/identity.test.ts

@@ -0,0 +1,76 @@
+/**
+ * First-principles co-installation guard: every identifier this extension
+ * registers into a shared Pi surface must be namespaced under PROVIDER_ID and
+ * disjoint from the official provider's reserved names.
+ *
+ * OFFICIAL_RESERVED mirrors @charmland/pi-hyper-provider@0.4.0's registration
+ * surface (src/hyper.ts, src/index.ts, src/settings.ts, src/credits.ts). Keep
+ * it in sync when the official package adds or renames a shared identifier: a
+ * failure here means the two extensions could collide on that surface.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+	API_KEY_ENV,
+	API_NAME,
+	IDENTIFIERS,
+	PRISM_ENTRY_TYPE,
+	PROVIDER_ID,
+	STATUS_COMMAND,
+	STATUS_KEY_ACCOUNT,
+	STATUS_KEY_SESSION,
+	WIDGET_KEY,
+} from "../identity.ts";
+
+const OFFICIAL_RESERVED = [
+	"hyper", // provider id and status key (PROVIDER_NAME)
+	"Charm Hyper", // provider + oauth display name
+	"hyper-status", // /hyper-status command
+	"hyper-prism-route", // prism entry customType
+	"hyper-provider", // ~/.pi/agent/hyper-provider settings dir
+	"HYPER_API_KEY", // envApiKeyAuth env var (auth key)
+	"openai-completions", // api name (openAICompletionsApi)
+	"@charmland/pi-hyper-provider", // npm package name
+];
+
+test("every registered identifier is namespaced under the provider id", () => {
+	for (const identifier of IDENTIFIERS) {
+		assert.equal(typeof identifier, "string");
+		assert.ok(identifier.length > 0);
+		// Normalize the two conventions we use: env vars are upper-cased
+		// (HYPERCHARM_API_KEY) and pi's env-var placeholders carry a "$" sigil.
+		const normalized = identifier.replace(/^\$/, "").toLowerCase();
+		assert.ok(normalized.startsWith(PROVIDER_ID), identifier + " must start with " + PROVIDER_ID);
+	}
+});
+
+test("identifiers are unique", () => {
+	assert.equal(new Set(IDENTIFIERS).size, IDENTIFIERS.length);
+});
+
+test("no identifier collides with the official provider's reserved names", () => {
+	for (const identifier of IDENTIFIERS) {
+		assert.ok(!OFFICIAL_RESERVED.includes(identifier), identifier + " collides with the official provider");
+	}
+});
+
+test("the specific shared surfaces differ from the official registration", () => {
+	assert.equal(PROVIDER_ID, "hypercharm");
+	assert.notEqual(PROVIDER_ID, "hyper");
+	assert.notEqual(API_NAME, "openai-completions");
+	assert.notEqual(API_KEY_ENV, "HYPER_API_KEY");
+	assert.notEqual(STATUS_COMMAND, "hyper-status");
+	assert.notEqual(PRISM_ENTRY_TYPE, "hyper-prism-route");
+	assert.notEqual(STATUS_KEY_SESSION, "hyper");
+	assert.notEqual(STATUS_KEY_ACCOUNT, "hyper");
+	assert.notEqual(WIDGET_KEY, "hyper");
+});
+
+test("status and widget keys stay disjoint so pi cannot cross-clear them", () => {
+	assert.ok(WIDGET_KEY.startsWith(PROVIDER_ID));
+	assert.ok(STATUS_KEY_SESSION.startsWith(PROVIDER_ID + "-"));
+	assert.ok(STATUS_KEY_ACCOUNT.startsWith(PROVIDER_ID + "-"));
+	assert.notEqual(STATUS_KEY_SESSION, STATUS_KEY_ACCOUNT);
+	assert.notEqual(STATUS_KEY_SESSION, WIDGET_KEY);
+	assert.notEqual(STATUS_KEY_ACCOUNT, WIDGET_KEY);
+});

package/tests/notify.test.ts

@@ -0,0 +1,111 @@
+/**
+ * The warning sink is the difference between a degraded session and a silent
+ * one, so its three behaviours are pinned here: deduplication, UI routing once
+ * a UI session activates it, and a stderr fallback when the captured ctx has
+ * gone stale (a refresh landing after its session was replaced).
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createNotifier } from "../notify.ts";
+
+function captureStderr() {
+	const chunks = [];
+	const original = process.stderr.write;
+	process.stderr.write = (chunk) => {
+		chunks.push(String(chunk));
+		return true;
+	};
+	return {
+		chunks,
+		restore() {
+			process.stderr.write = original;
+		},
+	};
+}
+
+function fakeContext(hasUI, notify) {
+	return { hasUI, ui: { notify: notify ?? (() => {}) } };
+}
+
+test("warnings are deduplicated and reach stderr before any UI exists", () => {
+	const stderr = captureStderr();
+	try {
+		const notifier = createNotifier();
+		notifier.warn("first failure");
+		notifier.warn("first failure");
+		notifier.warn("second failure");
+		const lines = stderr.chunks.filter((chunk) => chunk.includes("HyperCharm warning:"));
+		assert.equal(lines.length, 2, "each distinct warning is emitted once");
+		assert.ok(lines[0].includes("first failure"));
+		assert.ok(lines[1].includes("second failure"));
+	} finally {
+		stderr.restore();
+	}
+});
+
+test("activation routes later warnings through the session UI as warnings", () => {
+	const stderr = captureStderr();
+	try {
+		const notifications = [];
+		const notifier = createNotifier();
+		notifier.activate(fakeContext(true, (message, type) => notifications.push([message, type])));
+		notifier.warn("catalog refresh failed");
+		notifier.warn("catalog refresh failed");
+		assert.deepEqual(notifications, [["catalog refresh failed", "warning"]]);
+		assert.equal(
+			stderr.chunks.some((chunk) => chunk.includes("catalog refresh failed")),
+			false,
+			"an activated notifier must not also write to stderr",
+		);
+	} finally {
+		stderr.restore();
+	}
+});
+
+test("a stale context falls back to stderr instead of throwing", () => {
+	const stderr = captureStderr();
+	try {
+		const notifier = createNotifier();
+		notifier.activate(
+			fakeContext(true, () => {
+				throw new Error("This extension ctx is stale");
+			}),
+		);
+		assert.doesNotThrow(() => notifier.warn("after session replacement"));
+		assert.ok(stderr.chunks.some((chunk) => chunk.includes("after session replacement")));
+	} finally {
+		stderr.restore();
+	}
+});
+
+test("a non-UI session never claims the warning channel", () => {
+	const stderr = captureStderr();
+	try {
+		const notifications = [];
+		const notifier = createNotifier();
+		notifier.activate(fakeContext(false, (message) => notifications.push(message)));
+		notifier.warn("headless failure");
+		assert.deepEqual(notifications, []);
+		assert.ok(stderr.chunks.some((chunk) => chunk.includes("headless failure")));
+	} finally {
+		stderr.restore();
+	}
+});
+
+test("a context that throws on hasUI is ignored rather than fatal", () => {
+	const stderr = captureStderr();
+	try {
+		const notifier = createNotifier();
+		const hostile = {
+			get hasUI() {
+				throw new Error("stale ctx");
+			},
+			ui: { notify: () => {} },
+		};
+		assert.doesNotThrow(() => notifier.activate(hostile));
+		notifier.warn("still reported");
+		assert.ok(stderr.chunks.some((chunk) => chunk.includes("still reported")));
+	} finally {
+		stderr.restore();
+	}
+});

package/tests/prism.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { PRISM_ENTRY_TYPE, prismLabel, prismRouteFromHeaders, prismRouteLabel, readPrismRoute } from "../prism.ts";
+
+test("prismLabel accepts trimmed printable labels", () => {
+	assert.equal(prismLabel(" GLM 5.3 Flash "), "GLM 5.3 Flash");
+	assert.equal(prismLabel("glm-5.3-flash"), "glm-5.3-flash");
+	assert.equal(prismLabel("model-\u30c7\u30fc\u30bf"), "model-\u30c7\u30fc\u30bf");
+	assert.equal(prismLabel("x".repeat(200)), "x".repeat(200));
+});
+
+test("prismLabel rejects unusable labels", () => {
+	const rejected = [
+		undefined,
+		null,
+		42,
+		{},
+		[],
+		"",
+		"   ",
+		"x".repeat(201),
+		"bad\u001b[31m",
+		"bad\nline",
+		"bad\u202etext",
+		"bad\u0000",
+	];
+	for (const value of rejected) {
+		assert.equal(prismLabel(value), undefined, JSON.stringify(value));
+	}
+});
+
+test("prismRouteFromHeaders keeps whichever routing headers are usable", () => {
+	assert.deepEqual(
+		prismRouteFromHeaders({ "x-prism-model-name": " GLM 5.3 Flash ", "x-prism-model-id": "glm-5.3-flash" }),
+		{ modelName: "GLM 5.3 Flash", modelId: "glm-5.3-flash" },
+	);
+	assert.deepEqual(prismRouteFromHeaders({ "x-prism-model-name": "GLM 5.3 Flash" }), {
+		modelName: "GLM 5.3 Flash",
+		modelId: undefined,
+	});
+	assert.deepEqual(prismRouteFromHeaders({ "x-prism-model-id": "glm-5.3-flash" }), {
+		modelName: undefined,
+		modelId: "glm-5.3-flash",
+	});
+	assert.equal(prismRouteFromHeaders({}), undefined);
+	assert.equal(prismRouteFromHeaders({ "x-prism-model-name": "   " }), undefined);
+	assert.equal(prismRouteFromHeaders({ "x-prism-model-name": "bad\u001b[31m" }), undefined);
+	assert.equal(prismRouteFromHeaders({ "x-other-header": "glm-5.3-flash" }), undefined);
+	assert.equal(prismRouteFromHeaders(undefined), undefined);
+});
+
+test("persisted entry data is re-validated before rendering", () => {
+	assert.deepEqual(readPrismRoute({ modelName: "GLM 5.3 Flash" }), { modelName: "GLM 5.3 Flash", modelId: undefined });
+	assert.deepEqual(readPrismRoute({ modelId: "glm-5.3-flash" }), { modelName: undefined, modelId: "glm-5.3-flash" });
+	const rejected = [null, undefined, 42, "glm-5.3", [], { modelName: 42 }, { modelName: "bad\u001b[31m" }, { modelId: "bad\nline" }, {}];
+	for (const data of rejected) {
+		assert.equal(readPrismRoute(data), undefined, JSON.stringify(data));
+	}
+});
+
+test("the route label prefers the human name and the entry type stays namespaced", () => {
+	assert.equal(prismRouteLabel({ modelName: "GLM 5.3 Flash", modelId: "glm-5.3-flash" }), "GLM 5.3 Flash");
+	assert.equal(prismRouteLabel({ modelId: "glm-5.3-flash" }), "glm-5.3-flash");
+	assert.equal(prismRouteLabel({}), undefined);
+	assert.ok(PRISM_ENTRY_TYPE.startsWith("hypercharm"));
+	assert.notEqual(PRISM_ENTRY_TYPE, "hyper-prism-route");
+});