@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/git-changes.ts

@@ -0,0 +1,232 @@
+import { execFile } from "child_process";
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
+import { TEXT_PREVIEW_MAX_BYTES } from "./file-types";
+import type {
+  GitFileDiffResponse,
+  GitFileStatus,
+  GitStatusResponse,
+} from "./git-types";
+import {
+  classifyGitStatus,
+  parseGitPorcelainV1,
+  type GitPorcelainEntry,
+} from "./git-status";
+
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 10_000;
+const GIT_STATUS_MAX_BUFFER = 8 * 1024 * 1024;
+
+async function git(cwd: string, args: string[], maxBuffer = GIT_STATUS_MAX_BUFFER): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer,
+    env: { ...process.env, LC_ALL: "C" },
+  });
+  return stdout;
+}
+
+async function findRepositoryRoot(cwd: string): Promise<string | null> {
+  try {
+    return (await git(cwd, ["rev-parse", "--show-toplevel"])).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function isWithinPath(parent: string, target: string): boolean {
+  const relative = path.relative(path.resolve(parent), path.resolve(target));
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+function toGitPath(filePath: string): string {
+  return filePath.split(path.sep).join("/");
+}
+
+async function readStatusEntries(repositoryRoot: string): Promise<GitPorcelainEntry[]> {
+  const output = await git(repositoryRoot, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+  ]);
+  return parseGitPorcelainV1(output);
+}
+
+async function readTrackedLineStats(
+  repositoryRoot: string,
+  cwd: string,
+): Promise<{ additions: number; deletions: number }> {
+  const relativeCwd = toGitPath(path.relative(repositoryRoot, cwd));
+  const pathspec = relativeCwd || ".";
+  try {
+    const output = await git(repositoryRoot, [
+      "diff",
+      "--no-color",
+      "--no-ext-diff",
+      "--numstat",
+      "HEAD",
+      "--",
+      pathspec,
+    ]);
+    let additions = 0;
+    let deletions = 0;
+    for (const line of output.split(/\r?\n/)) {
+      if (!line) continue;
+      const [added, deleted] = line.split("\t", 2);
+      const addedCount = Number(added);
+      const deletedCount = Number(deleted);
+      if (Number.isInteger(addedCount)) additions += addedCount;
+      if (Number.isInteger(deletedCount)) deletions += deletedCount;
+    }
+    return { additions, deletions };
+  } catch {
+    return { additions: 0, deletions: 0 };
+  }
+}
+
+function countUntrackedTextLines(filePath: string): number {
+  try {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.size > TEXT_PREVIEW_MAX_BYTES) return 0;
+    const content = fs.readFileSync(filePath);
+    if (hasNullByte(content) || content.length === 0) return 0;
+    const text = content.toString("utf8");
+    return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+
+export async function getGitStatus(cwd: string): Promise<GitStatusResponse> {
+  const repositoryRoot = await findRepositoryRoot(cwd);
+  if (!repositoryRoot) {
+    return {
+      isGitRepository: false,
+      repositoryRoot: null,
+      files: [],
+      additions: 0,
+      deletions: 0,
+    };
+  }
+
+  const [entries, trackedLineStats] = await Promise.all([
+    readStatusEntries(repositoryRoot),
+    readTrackedLineStats(repositoryRoot, cwd),
+  ]);
+  const files = entries.flatMap((entry): GitFileStatus[] => {
+    const filePath = path.resolve(repositoryRoot, entry.path);
+    if (!isWithinPath(cwd, filePath)) return [];
+    const classified = classifyGitStatus(entry);
+    return [{
+      filePath,
+      ...classified,
+      indexStatus: entry.indexStatus,
+      worktreeStatus: entry.worktreeStatus,
+    }];
+  });
+  const untrackedAdditions = files.reduce(
+    (total, file) => total + (file.status === "untracked" ? countUntrackedTextLines(file.filePath) : 0),
+    0,
+  );
+
+  return {
+    isGitRepository: true,
+    repositoryRoot,
+    files,
+    additions: trackedLineStats.additions + untrackedAdditions,
+    deletions: trackedLineStats.deletions,
+  };
+}
+
+function hasNullByte(content: Buffer): boolean {
+  return content.includes(0);
+}
+
+function createAddedFilePatch(gitPath: string, content: string): string {
+  const hasTrailingNewline = content.endsWith("\n");
+  const lines = content.split("\n");
+  if (hasTrailingNewline) lines.pop();
+  const body = lines.map((line) => `+${line}`).join("\n");
+  const noNewlineMarker = !hasTrailingNewline && lines.length > 0
+    ? "\n\"
+    : "";
+  return [
+    `diff --git a/${gitPath} b/${gitPath}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${gitPath}`,
+    `@@ -0,0 +1,${lines.length} @@`,
+    `${body}${noNewlineMarker}`,
+  ].join("\n");
+}
+
+async function createTrackedFilePatch(
+  repositoryRoot: string,
+  relativePath: string,
+  originalPath?: string,
+): Promise<string | null> {
+  const paths = originalPath && originalPath !== relativePath
+    ? [originalPath, relativePath]
+    : [relativePath];
+  try {
+    return await git(repositoryRoot, [
+      "diff",
+      "--no-color",
+      "--no-ext-diff",
+      "--unified=3",
+      "HEAD",
+      "--",
+      ...paths,
+    ], TEXT_PREVIEW_MAX_BYTES * 4);
+  } catch {
+    return null;
+  }
+}
+
+export async function getGitFileDiff(cwd: string, filePath: string): Promise<GitFileDiffResponse> {
+  const repositoryRoot = await findRepositoryRoot(cwd);
+  if (!repositoryRoot || !isWithinPath(repositoryRoot, filePath)) return { supported: false };
+
+  const resolvedFilePath = path.resolve(filePath);
+  const relativePath = toGitPath(path.relative(repositoryRoot, resolvedFilePath));
+  const entries = await readStatusEntries(repositoryRoot);
+  const entry = entries.find((candidate) => candidate.path === relativePath);
+  if (!entry) return { supported: false };
+
+  const { status } = classifyGitStatus(entry);
+  if (status === "deleted") {
+    const patch = await createTrackedFilePatch(repositoryRoot, relativePath, entry.originalPath);
+    if (!patch?.includes("\n@@ ")) return { supported: false };
+    return { supported: true, status, patch };
+  }
+
+  let stat: fs.Stats;
+  try {
+    stat = fs.lstatSync(resolvedFilePath);
+  } catch {
+    return { supported: false };
+  }
+  if (!stat.isFile() || stat.size > TEXT_PREVIEW_MAX_BYTES) return { supported: false };
+
+  const currentBuffer = fs.readFileSync(resolvedFilePath);
+  if (hasNullByte(currentBuffer)) return { supported: false };
+  const newContent = currentBuffer.toString("utf8");
+
+  let patch: string;
+  if (status === "untracked") {
+    patch = createAddedFilePatch(relativePath, newContent);
+  } else {
+    const trackedPatch = await createTrackedFilePatch(repositoryRoot, relativePath, entry.originalPath);
+    if (trackedPatch === null) {
+      if (status !== "added") return { supported: false };
+      patch = createAddedFilePatch(relativePath, newContent);
+    } else {
+      patch = trackedPatch;
+    }
+  }
+
+  if (!patch.includes("\n@@ ")) return { supported: false };
+  return { supported: true, status, patch };
+}

package/lib/git-status.ts

@@ -0,0 +1,47 @@
+import type { GitFileStatus } from "./git-types";
+
+export interface GitPorcelainEntry {
+  path: string;
+  originalPath?: string;
+  indexStatus: string;
+  worktreeStatus: string;
+}
+
+function usesRenamePath(indexStatus: string, worktreeStatus: string): boolean {
+  return indexStatus === "R" || indexStatus === "C" || worktreeStatus === "R" || worktreeStatus === "C";
+}
+
+export function parseGitPorcelainV1(output: string): GitPorcelainEntry[] {
+  const records = output.split("\0");
+  const entries: GitPorcelainEntry[] = [];
+
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    if (!record || record.length < 4 || record[2] !== " ") continue;
+    const indexStatus = record[0];
+    const worktreeStatus = record[1];
+    const entry: GitPorcelainEntry = {
+      path: record.slice(3),
+      indexStatus,
+      worktreeStatus,
+    };
+    if (usesRenamePath(indexStatus, worktreeStatus)) {
+      entry.originalPath = records[++i] || undefined;
+    }
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
+const CONFLICT_STATUSES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+
+export function classifyGitStatus(entry: GitPorcelainEntry): Pick<GitFileStatus, "status" | "code"> {
+  const pair = `${entry.indexStatus}${entry.worktreeStatus}`;
+  if (pair === "??") return { status: "untracked", code: "U" };
+  if (CONFLICT_STATUSES.has(pair) || pair.includes("U")) return { status: "conflict", code: "C" };
+  if (pair.includes("D")) return { status: "deleted", code: "D" };
+  if (pair.includes("R") || pair.includes("C")) return { status: "renamed", code: "R" };
+  if (pair.includes("A")) return { status: "added", code: "A" };
+  return { status: "modified", code: "M" };
+}

package/lib/git-types.ts

@@ -0,0 +1,29 @@
+export type GitFileStatusKind =
+  | "modified"
+  | "added"
+  | "deleted"
+  | "renamed"
+  | "untracked"
+  | "conflict";
+
+export interface GitFileStatus {
+  filePath: string;
+  status: GitFileStatusKind;
+  code: "M" | "A" | "D" | "R" | "U" | "C";
+  indexStatus: string;
+  worktreeStatus: string;
+}
+
+export interface GitStatusResponse {
+  isGitRepository: boolean;
+  repositoryRoot: string | null;
+  files: GitFileStatus[];
+  additions: number;
+  deletions: number;
+}
+
+export interface GitFileDiffResponse {
+  supported: boolean;
+  status?: GitFileStatusKind;
+  patch?: string;
+}

package/lib/http-dispatcher.test.mjs

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { once } from "node:events";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const PROXY_ENV_KEYS = [
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "ALL_PROXY",
+  "all_proxy",
+];
+
+test("configures HTTP_PROXY, HTTPS_PROXY, and NO_PROXY for global fetch", async (t) => {
+  const originalEnv = new Map(PROXY_ENV_KEYS.map((key) => [key, process.env[key]]));
+  for (const key of PROXY_ENV_KEYS) delete process.env[key];
+
+  const connectTargets = [];
+  const forwardedRequests = [];
+  const proxy = createServer((req, res) => {
+    forwardedRequests.push(`${req.method} ${req.url}`);
+    res.writeHead(204, { Connection: "close" });
+    res.end();
+  });
+  proxy.on("connect", (req, socket) => {
+    connectTargets.push(req.url);
+    socket.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+  });
+  proxy.listen(0, "127.0.0.1");
+  await once(proxy, "listening");
+
+  t.after(async () => {
+    for (const [key, value] of originalEnv) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    await new Promise((resolve, reject) => {
+      proxy.close((error) => error ? reject(error) : resolve());
+    });
+  });
+
+  const address = proxy.address();
+  assert.ok(address && typeof address === "object");
+  const proxyUrl = `http://127.0.0.1:${address.port}`;
+  process.env.HTTP_PROXY = proxyUrl;
+  process.env.HTTPS_PROXY = proxyUrl;
+  process.env.NO_PROXY = "bypass.invalid";
+
+  const jiti = createJiti(import.meta.url);
+  const { configureHttpDispatcher } = await jiti.import("./http-dispatcher.ts");
+  const { getGlobalDispatcher } = await import("undici");
+
+  assert.throws(() => configureHttpDispatcher(-1), /Invalid HTTP idle timeout/);
+  configureHttpDispatcher(2_000);
+
+  const dispatcher = getGlobalDispatcher();
+  configureHttpDispatcher(5_000);
+  assert.equal(getGlobalDispatcher(), dispatcher, "configuration should be idempotent");
+
+  const httpResponse = await fetch("http://target.invalid/through-http-proxy", {
+    signal: AbortSignal.timeout(2_000),
+  });
+  assert.equal(httpResponse.status, 204);
+  assert.deepEqual(forwardedRequests, ["GET http://target.invalid/through-http-proxy"]);
+  assert.deepEqual(connectTargets, []);
+
+  await assert.rejects(fetch("https://target.invalid/through-https-proxy", {
+    signal: AbortSignal.timeout(2_000),
+  }));
+  assert.deepEqual(connectTargets, ["target.invalid:443"]);
+
+  const forwardedRequestCount = forwardedRequests.length;
+  const connectTargetCount = connectTargets.length;
+  await assert.rejects(fetch("http://bypass.invalid:9/no-proxy", {
+    signal: AbortSignal.timeout(2_000),
+  }));
+  assert.equal(forwardedRequests.length, forwardedRequestCount);
+  assert.equal(connectTargets.length, connectTargetCount);
+});

package/lib/http-dispatcher.ts

@@ -0,0 +1,86 @@
+import { EventEmitter } from "node:events";
+import * as undici from "undici";
+
+export const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300_000;
+
+type DispatcherGlobal = typeof globalThis & {
+  __piWebHttpDispatcherConfigured?: boolean;
+};
+
+const dispatcherGlobal = globalThis as DispatcherGlobal;
+const originalGlobalFetch = globalThis.fetch;
+const ignoreUndiciDispatcherError = (): void => {};
+
+function parseHttpIdleTimeoutMs(value: unknown): number | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.toLowerCase() === "disabled") return 0;
+    if (trimmed.length === 0) return undefined;
+    return parseHttpIdleTimeoutMs(Number(trimmed));
+  }
+
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return undefined;
+  }
+  return Math.floor(value);
+}
+
+// Undici can emit an internal Client error while terminating a response body.
+// The body stream still rejects; this prevents the EventEmitter error from
+// terminating the Next.js process first.
+function withUndiciErrorListener<T extends undici.Dispatcher>(dispatcher: T): T {
+  if (dispatcher instanceof EventEmitter) {
+    EventEmitter.prototype.on.call(dispatcher, "error", ignoreUndiciDispatcherError);
+  }
+  return dispatcher;
+}
+
+function createUndiciClient(origin: string | URL, options: object): undici.Dispatcher {
+  return withUndiciErrorListener(
+    new undici.Client(origin, options as undici.Client.Options),
+  );
+}
+
+function createUndiciOriginDispatcher(origin: string | URL, options: object): undici.Dispatcher {
+  const dispatcherOptions = options as undici.Pool.Options;
+  if (dispatcherOptions.connections === 1) {
+    return createUndiciClient(origin, dispatcherOptions);
+  }
+
+  return withUndiciErrorListener(
+    new undici.Pool(origin, {
+      ...dispatcherOptions,
+      factory: createUndiciClient,
+    }),
+  );
+}
+
+export function configureHttpDispatcher(
+  timeoutMs: number = DEFAULT_HTTP_IDLE_TIMEOUT_MS,
+): void {
+  if (dispatcherGlobal.__piWebHttpDispatcherConfigured) return;
+
+  const normalizedTimeoutMs = parseHttpIdleTimeoutMs(timeoutMs);
+  if (normalizedTimeoutMs === undefined) {
+    throw new Error(`Invalid HTTP idle timeout: ${String(timeoutMs)}`);
+  }
+
+  const dispatcher = withUndiciErrorListener(
+    new undici.EnvHttpProxyAgent({
+      allowH2: false,
+      bodyTimeout: normalizedTimeoutMs,
+      headersTimeout: normalizedTimeoutMs,
+      clientFactory: createUndiciClient,
+      factory: createUndiciOriginDispatcher,
+    }),
+  );
+  undici.setGlobalDispatcher(dispatcher);
+
+  // Keep fetch and the dispatcher on the same undici implementation. Preserve
+  // an intentional fetch override installed after this module was loaded.
+  if (globalThis.fetch === originalGlobalFetch) {
+    undici.install?.();
+  }
+
+  dispatcherGlobal.__piWebHttpDispatcherConfigured = true;
+}

package/lib/i18n/format.test.mjs

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { formatRelativeTime, interpolateMessage, translateMessage } from "./format.ts";
+
+test("interpolates string and numeric parameters", () => {
+  assert.equal(interpolateMessage("Hello, {name} ({count})", { name: "Pi", count: 2 }), "Hello, Pi (2)");
+});
+
+test("falls back to English and returns the key when both are missing", () => {
+  assert.equal(translateMessage("zh-CN", "common.ok", { en: { "common.ok": "OK" }, "zh-CN": {} }), "OK");
+  assert.equal(translateMessage("zh-CN", "missing.key", { en: {}, "zh-CN": {} }), "missing.key");
+});
+
+test("formats relative time using the selected locale", () => {
+  const now = new Date("2026-01-01T00:00:00.000Z");
+  assert.equal(formatRelativeTime(new Date("2026-01-01T00:05:00.000Z"), "en", now), "in 5 minutes");
+  assert.equal(formatRelativeTime(new Date("2025-12-31T23:00:00.000Z"), "zh-CN", now), "1小时前");
+});

package/lib/i18n/format.ts

@@ -0,0 +1,60 @@
+import type { Locale, TranslationParams } from "./types";
+
+type MessagesByLocale = Record<string, Record<string, string>>;
+
+/**
+ * 替换翻译消息中的简单插值占位符。
+ * @param message 原始翻译消息
+ * @param params 插值参数
+ * @returns 完成参数替换后的消息
+ */
+export function interpolateMessage(message: string, params: TranslationParams = {}): string {
+  return message.replace(/\{([\w.-]+)\}/g, (token, name: string) => {
+    const value = params[name];
+    return value === undefined ? token : String(value);
+  });
+}
+
+/**
+ * 从当前语言和英语语言包中解析消息。
+ * @param locale 当前语言
+ * @param key 翻译 key
+ * @param messages 各语言的消息字典
+ * @param params 可选的插值参数
+ * @returns 翻译结果，缺失时返回 key
+ */
+export function translateMessage(
+  locale: Locale,
+  key: string,
+  messages: MessagesByLocale,
+  params: TranslationParams = {},
+): string {
+  const message = messages[locale]?.[key] ?? messages.en?.[key];
+  if (message === undefined) {
+    if (process.env.NODE_ENV !== "production") console.warn(`[i18n] Missing translation: ${key}`);
+    return key;
+  }
+  return interpolateMessage(message, params);
+}
+
+/**
+ * 按当前语言格式化相对时间。
+ * @param date 要格式化的时间
+ * @param locale 当前语言
+ * @param now 用于测试或特殊场景的当前时间
+ * @returns locale-aware 的相对时间文本
+ */
+export function formatRelativeTime(date: Date | string, locale: Locale, now = new Date()): string {
+  const target = date instanceof Date ? date : new Date(date);
+  const diffMs = target.getTime() - now.getTime();
+  const absMs = Math.abs(diffMs);
+  const [unit, divisor] = absMs < 60_000
+    ? ["second", 1_000]
+    : absMs < 3_600_000
+      ? ["minute", 60_000]
+      : absMs < 86_400_000
+        ? ["hour", 3_600_000]
+        : ["day", 86_400_000];
+  const value = Math.round(diffMs / divisor);
+  return new Intl.RelativeTimeFormat(locale, { numeric: "always" }).format(value, unit as Intl.RelativeTimeFormatUnit);
+}