@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/i18n/registry.test.mjs

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  getLocalePlugin,
+  getSupportedLocales,
+  registerLocale,
+  resolveBrowserLocale,
+} = await jiti.import("./registry.ts");
+
+test("uses the first supported browser language and falls back to English", () => {
+  assert.equal(resolveBrowserLocale(["zh-CN", "en-US"]), "zh-CN");
+  assert.equal(resolveBrowserLocale(["zh", "en-US"]), "zh-CN");
+  assert.equal(resolveBrowserLocale(["en-US", "zh-CN"]), "en");
+  assert.equal(resolveBrowserLocale(["fr-FR", "zh-CN"]), "zh-CN");
+  assert.equal(resolveBrowserLocale(["fr-FR"]), "en");
+  assert.equal(resolveBrowserLocale([]), "en");
+});
+
+test("returns only registered locales", () => {
+  assert.deepEqual(getSupportedLocales(), ["en", "zh-CN"]);
+  assert.equal(getLocalePlugin("en").id, "en");
+  assert.equal(getLocalePlugin("missing"), undefined);
+});
+
+test("allows a new locale plugin and rejects duplicate ids", () => {
+  registerLocale({ id: "test", label: "Test", messages: { "common.ok": "OK" } });
+  assert.equal(getLocalePlugin("test")?.label, "Test");
+  assert.throws(() => registerLocale({ id: "test", label: "Again", messages: {} }));
+});

package/lib/i18n/registry.ts

@@ -0,0 +1,43 @@
+import { enLocale } from "./messages/en";
+import { zhCNLocale } from "./messages/zh-CN";
+import type { Locale, LocalePlugin } from "./types";
+
+const localePlugins = new Map<string, LocalePlugin>();
+
+/** 注册一个语言包；重复注册会抛出异常，避免静默覆盖翻译。 */
+export function registerLocale(plugin: LocalePlugin): void {
+  if (!plugin.id.trim()) throw new Error("Locale id must not be empty");
+  if (localePlugins.has(plugin.id)) throw new Error(`Locale already registered: ${plugin.id}`);
+  localePlugins.set(plugin.id, plugin);
+}
+
+/**
+ * 根据标识获取已注册的语言包。
+ * @param id 要查询的语言标识
+ * @returns 已注册的语言包，不存在时返回 undefined
+ */
+export function getLocalePlugin(id: string): LocalePlugin | undefined {
+  return localePlugins.get(id);
+}
+
+/** 获取当前已注册语言的稳定顺序列表。 */
+export function getSupportedLocales(): string[] {
+  return [...localePlugins.keys()];
+}
+
+/**
+ * 将浏览器语言列表解析为 Pi Web 内置语言。
+ * @param languages 浏览器按优先级排列的语言列表
+ * @returns 匹配的内置语言，无法匹配时返回英语
+ */
+export function resolveBrowserLocale(languages: readonly string[]): Locale {
+  for (const language of languages) {
+    const normalized = language.toLowerCase();
+    if (normalized === "en" || normalized.startsWith("en-")) return "en";
+    if (normalized === "zh" || normalized.startsWith("zh-")) return "zh-CN";
+  }
+  return "en";
+}
+
+registerLocale(enLocale);
+registerLocale(zhCNLocale);

package/lib/i18n/types.ts

@@ -0,0 +1,15 @@
+/** 内置的可用界面语言。 */
+export type Locale = "en" | "zh-CN";
+
+/** 翻译字符串使用的简单插值参数。 */
+export type TranslationParams = Record<string, string | number>;
+
+/** 可注册的语言包定义。 */
+export interface LocalePlugin {
+  /** 语言包唯一标识。 */
+  id: string;
+  /** 用于语言选择菜单的显示名称。 */
+  label: string;
+  /** 以稳定 key 索引的翻译消息。 */
+  messages: Record<string, string>;
+}

package/lib/image-attachments.test.mjs

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./image-attachments.ts");
+}
+
+const image = { type: "image", mimeType: "image/png", data: "YWJj" };
+
+test("calculates padded base64 byte lengths and rejects invalid data", async () => {
+  const { getBase64DecodedByteLength } = await loadSubject();
+
+  assert.equal(getBase64DecodedByteLength("YQ=="), 1);
+  assert.equal(getBase64DecodedByteLength("YWI="), 2);
+  assert.equal(getBase64DecodedByteLength("YWJj"), 3);
+  assert.equal(getBase64DecodedByteLength("not base64!"), null);
+});
+
+test("rejects invalid, oversized, and too many image attachments", async () => {
+  const { MAX_ATTACHED_IMAGE_BYTES, MAX_ATTACHED_IMAGES, validateAgentImages } = await loadSubject();
+  const oversizedData = "AAAA".repeat(Math.ceil((MAX_ATTACHED_IMAGE_BYTES + 1) / 3));
+
+  assert.equal(validateAgentImages([image]), null);
+  assert.match(validateAgentImages([{ ...image, mimeType: "text/plain" }]), /valid base64 image/);
+  assert.match(validateAgentImages([{ ...image, data: oversizedData }]), /10MB/);
+  assert.match(validateAgentImages(Array.from({ length: MAX_ATTACHED_IMAGES + 1 }, () => image)), /at most/);
+});

package/lib/image-attachments.ts

@@ -0,0 +1,56 @@
+export const MAX_ATTACHED_IMAGE_BYTES = 10 * 1024 * 1024;
+export const MAX_ATTACHED_IMAGES = 10;
+
+export interface Base64ImageAttachment {
+  data: string;
+  mimeType: string;
+}
+
+function isBase64DataChar(code: number): boolean {
+  return (code >= 0x41 && code <= 0x5a)
+    || (code >= 0x61 && code <= 0x7a)
+    || (code >= 0x30 && code <= 0x39)
+    || code === 0x2b
+    || code === 0x2f;
+}
+
+export function getBase64DecodedByteLength(data: string): number | null {
+  if (!data || data.length % 4 !== 0) return null;
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  const dataEnd = data.length - padding;
+  for (let index = 0; index < dataEnd; index += 1) {
+    if (!isBase64DataChar(data.charCodeAt(index))) return null;
+  }
+  for (let index = dataEnd; index < data.length; index += 1) {
+    if (data[index] !== "=") return null;
+  }
+  return (data.length / 4) * 3 - padding;
+}
+
+export function isBase64ImageWithinLimits(value: unknown): value is Base64ImageAttachment {
+  if (!value || typeof value !== "object") return false;
+  const image = value as Partial<Base64ImageAttachment>;
+  if (typeof image.data !== "string" || typeof image.mimeType !== "string" || !image.mimeType.startsWith("image/")) {
+    return false;
+  }
+  const bytes = getBase64DecodedByteLength(image.data);
+  return bytes !== null && bytes <= MAX_ATTACHED_IMAGE_BYTES;
+}
+
+/** Return an API-safe error for prompt, steering, and follow-up image arrays. */
+export function validateAgentImages(value: unknown): string | null {
+  if (value === undefined) return null;
+  if (!Array.isArray(value)) return "images must be an array";
+  if (value.length > MAX_ATTACHED_IMAGES) {
+    return `A message can include at most ${MAX_ATTACHED_IMAGES} images`;
+  }
+  for (const image of value) {
+    if (!image || typeof image !== "object" || (image as { type?: unknown }).type !== "image") {
+      return "Each attachment must be an image";
+    }
+    if (!isBase64ImageWithinLimits(image)) {
+      return `Each image must be valid base64 image data of ${MAX_ATTACHED_IMAGE_BYTES / (1024 * 1024)}MB or smaller`;
+    }
+  }
+  return null;
+}

package/lib/initial-navigation.test.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./initial-navigation.ts");
+}
+
+test("uses cwd instead of session when both parameters are present", async () => {
+  const { getInitialNavigation } = await loadSubject();
+  const result = getInitialNavigation(new URLSearchParams({
+    cwd: " /work/project ",
+    session: "saved-session",
+  }));
+
+  assert.deepEqual(result, {
+    requestedCwd: "/work/project",
+    sessionId: null,
+    boardId: null,
+  });
+});
+
+test("restores session when cwd is absent", async () => {
+  const { getInitialNavigation } = await loadSubject();
+
+  assert.deepEqual(
+    getInitialNavigation(new URLSearchParams({ session: "saved-session" })),
+    { requestedCwd: null, sessionId: "saved-session", boardId: null },
+  );
+});
+
+test("treats an empty cwd as absent", async () => {
+  const { getInitialNavigation } = await loadSubject();
+
+  assert.deepEqual(
+    getInitialNavigation(new URLSearchParams({ cwd: "  ", session: "saved-session" })),
+    { requestedCwd: null, sessionId: "saved-session", boardId: null },
+  );
+});
+
+test("preserves a URL-encoded Windows path", async () => {
+  const { getInitialNavigation } = await loadSubject();
+
+  assert.deepEqual(
+    getInitialNavigation(new URLSearchParams("cwd=C%3A%5CProjects%5Cpi-web")),
+    { requestedCwd: "C:\\Projects\\pi-web", sessionId: null, boardId: null },
+  );
+});
+
+test("restores board from ?board= param", async () => {
+  const { getInitialNavigation } = await loadSubject();
+
+  assert.deepEqual(
+    getInitialNavigation(new URLSearchParams({ board: "my-board-id" })),
+    { requestedCwd: null, sessionId: null, boardId: "my-board-id" },
+  );
+});
+
+test("board param does not interfere with cwd", async () => {
+  const { getInitialNavigation } = await loadSubject();
+
+  assert.deepEqual(
+    getInitialNavigation(new URLSearchParams({ cwd: "/work", board: "b1" })),
+    { requestedCwd: "/work", sessionId: null, boardId: "b1" },
+  );
+});

package/lib/initial-navigation.ts

@@ -0,0 +1,15 @@
+export interface InitialNavigation {
+  requestedCwd: string | null;
+  sessionId: string | null;
+  boardId: string | null;
+}
+
+export function getInitialNavigation(searchParams: Pick<URLSearchParams, "get">): InitialNavigation {
+  const requestedCwd = searchParams.get("cwd")?.trim() || null;
+
+  return {
+    requestedCwd,
+    sessionId: requestedCwd ? null : searchParams.get("session"),
+    boardId: searchParams.get("board")?.trim() || null,
+  };
+}

package/lib/markdown.test.mjs

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { normalizeDisplayMath } from "./markdown.ts";
+
+describe("normalizeDisplayMath", () => {
+  describe("single-line $$…$$", () => {
+    it("splits a single-line block into three lines", () => {
+      assert.equal(normalizeDisplayMath("$$a + b$$"), "$$\na + b\n$$");
+    });
+
+    it("preserves the indent of the surrounding list item", () => {
+      assert.equal(
+        normalizeDisplayMath("- item:\n  $$a + b$$\n- next"),
+        "- item:\n  $$\n  a + b\n  $$\n- next",
+      );
+    });
+  });
+
+  describe("multi-line blocks with glued delimiters", () => {
+    it("moves a glued opening delimiter to its own line", () => {
+      const input = "$$\n\\frac{a}{b} = c\n<d$$\n\nafter";
+      assert.equal(normalizeDisplayMath(input), "$$\n\\frac{a}{b} = c\n<d\n$$\n\nafter");
+    });
+
+    it("moves a glued closing delimiter to its own line", () => {
+      const input = "$$\nx = y\nz = w$$\n\nafter";
+      assert.equal(normalizeDisplayMath(input), "$$\nx = y\nz = w\n$$\n\nafter");
+    });
+  });
+
+  describe("blocks nested in GFM list items", () => {
+    it("re-indents lazy content lines of an indented bare-fence block", () => {
+      const input = "- item:\n  $$\nx = y\n  $$\n- next";
+      assert.equal(normalizeDisplayMath(input), "- item:\n  $$\n  x = y\n  $$\n- next");
+    });
+
+    it("re-indents partially indented content lines", () => {
+      const input = "- item:\n  $$\n x = y\n  $$\n- next";
+      assert.equal(normalizeDisplayMath(input), "- item:\n  $$\n  x = y\n  $$\n- next");
+    });
+
+    it("does not use a sibling list item's formula as a closing fence", () => {
+      const input = "- first\n  $$x = y\n- second\n  $$z = w$$\n- third";
+      assert.equal(
+        normalizeDisplayMath(input),
+        "- first\n  $$x = y\n- second\n  $$\n  z = w\n  $$\n- third",
+      );
+    });
+
+    it("does not scan a bare fence past a sibling list item", () => {
+      const input = "- first\n  $$\nx = y\n- second\n  $$z = w$$\n- third";
+      assert.equal(
+        normalizeDisplayMath(input),
+        "- first\n  $$\nx = y\n- second\n  $$\n  z = w\n  $$\n- third",
+      );
+    });
+  });
+
+  describe("blocks that must stay untouched", () => {
+    it("leaves a top-level block with detached delimiters untouched", () => {
+      const input = "$$\n\\frac{a}{b}\n$$\n\nend";
+      assert.equal(normalizeDisplayMath(input), input);
+    });
+
+    it("leaves content inside fenced code blocks untouched", () => {
+      const input = "```\n$$ not math $$\n$$\n```\n\nreal $$x = 1$$ end";
+      const normalized = normalizeDisplayMath(input);
+      assert.ok(normalized.includes("```\n$$ not math $$\n$$\n```"));
+      // every `$$` is preserved: 3 inside the fence + 2 in inline math
+      assert.equal(normalized.match(/\$\$/g)?.length, 5);
+    });
+
+    it("leaves inline math and plain prose untouched", () => {
+      const input = "text $x = 1$ and $$a + b$$ more";
+      assert.equal(normalizeDisplayMath(input), input);
+    });
+
+    it("does not treat a glued opener with mid-line $$ as a block", () => {
+      const input = "$$x$$ and text";
+      assert.equal(normalizeDisplayMath(input), input);
+    });
+  });
+
+  describe("\\[ … \\] blocks", () => {
+    it("normalizes single-line brackets", () => {
+      assert.equal(normalizeDisplayMath("\\[a + b\\]"), "$$\na + b\n$$");
+    });
+
+    it("keeps content indented when nested in a list item", () => {
+      assert.equal(
+        normalizeDisplayMath("- item:\n  \\[a + b\\]\n- next"),
+        "- item:\n  $$\n  a + b\n  $$\n- next",
+      );
+    });
+
+    it("normalizes multi-line brackets without double-indenting", () => {
+      assert.equal(
+        normalizeDisplayMath("- item:\n  \\[\n  x = y\n  \\]\n- next"),
+        "- item:\n  $$\n  x = y\n  $$\n- next",
+      );
+    });
+  });
+});