@herbertgao/pi-extensions 2026.9.3 → 2026.9.4

package/node_modules/pi-antigravity/src/utils/http.ts

@@ -0,0 +1,91 @@
+import { antigravityEnv } from "./util.js";
+
+/**
+ * Node's built-in fetch keeps an idle socket for only 4 seconds unless the server
+ * advertises a longer `Keep-Alive: timeout=`. The Cloud Code Assist endpoint sends no
+ * such header, and interactive coding turns are almost always more than 4 seconds
+ * apart, so without a dedicated pool every message pays a fresh DNS + TCP + TLS
+ * handshake. A long-lived dispatcher removes that per-turn setup cost.
+ *
+ * The dispatcher is scoped to this provider's requests rather than installed with
+ * `setGlobalDispatcher`, so it never changes HTTP behaviour for the rest of the host
+ * process or for other extensions.
+ *
+ * Node 22+ global `fetch` cannot take an npm `undici.Agent` (handler mismatch).
+ * Those runtimes already pool connections natively, so we skip the custom Agent.
+ */
+const KEEP_ALIVE_TIMEOUT_MS = 60_000;
+const KEEP_ALIVE_MAX_TIMEOUT_MS = 5 * 60_000;
+const CONNECT_TIMEOUT_MS = 10_000;
+const PREWARM_TIMEOUT_MS = 5_000;
+
+/** `dispatcher` is an undici extension to RequestInit that Node's fetch honours. */
+type DispatcherInit = RequestInit & { dispatcher?: unknown };
+
+let dispatcherPromise: Promise<unknown> | undefined;
+
+function hasProxyConfiguration(): boolean {
+  return ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"].some(
+    (name) => Boolean(process.env[name]?.trim()),
+  );
+}
+
+async function getDispatcher(): Promise<unknown> {
+  dispatcherPromise ??= (async () => {
+    // Pi configures a proxy-aware global dispatcher. Passing a private Agent here
+    // would bypass it and make Antigravity requests connect directly instead.
+    if (antigravityEnv("NO_KEEPALIVE") === "1" || hasProxyConfiguration()) {
+      return undefined;
+    }
+    const nodeMajor = Number(process.versions.node?.split(".")[0]);
+    if (!Number.isNaN(nodeMajor) && nodeMajor >= 22) {
+      return undefined;
+    }
+    try {
+      const { Agent } = await import("undici");
+      return new Agent({
+        keepAliveTimeout: KEEP_ALIVE_TIMEOUT_MS,
+        keepAliveMaxTimeout: KEEP_ALIVE_MAX_TIMEOUT_MS,
+        connections: 8,
+        connect: { timeout: CONNECT_TIMEOUT_MS },
+        // HTTP/2 is opt-in: the endpoint negotiates it, but moving SSE onto h2 is a
+        // transport change we do not want to force on every user.
+        allowH2: antigravityEnv("HTTP2") === "1",
+      });
+    } catch {
+      // undici unavailable — fall back to Node's default fetch behaviour.
+      return undefined;
+    }
+  })();
+  return dispatcherPromise;
+}
+
+/** fetch() bound to this provider's keep-alive connection pool when available. */
+export async function antigravityFetch(
+  input: string | URL,
+  init: RequestInit = {},
+): Promise<Response> {
+  const dispatcher = await getDispatcher();
+  if (!dispatcher) return fetch(input, init);
+  return fetch(input, { ...init, dispatcher } as DispatcherInit);
+}
+
+/**
+ * Open the TLS connection when the extension loads so the first message of a session
+ * does not pay the handshake either. Best-effort: failures are ignored.
+ */
+export function prewarmConnection(url: string): void {
+  if (antigravityEnv("NO_PREWARM") === "1") return;
+  void (async () => {
+    try {
+      const res = await antigravityFetch(url, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(PREWARM_TIMEOUT_MS),
+      });
+      // Release the socket back to the pool even though HEAD carries no body.
+      await res.arrayBuffer();
+    } catch {
+      // Warm-up only; the real request will establish the connection instead.
+    }
+  })();
+}

package/node_modules/pi-antigravity/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./util.js";
+export * from "./security.js";
+export * from "./http.js";

package/node_modules/pi-antigravity/src/utils/security.ts

@@ -0,0 +1,73 @@
+import { antigravityEnv } from "./util.js";
+
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "::1", "localhost"]);
+const ALLOWED_API_HOST_SUFFIXES = [".googleapis.com", ".sandbox.googleapis.com"];
+
+/** Only loopback binds are allowed so OAuth codes cannot be stolen off-machine. */
+export function resolveCallbackHost(raw = antigravityEnv("CALLBACK_HOST")): string {
+  const host = (raw || "127.0.0.1").trim().toLowerCase();
+  if (!LOOPBACK_HOSTS.has(host)) {
+    throw new Error(
+      `Unsafe ANTIGRAVITY_CALLBACK_HOST="${host}". Only loopback hosts are allowed: 127.0.0.1, ::1, localhost.`,
+    );
+  }
+  return host === "localhost" ? "127.0.0.1" : host;
+}
+
+/** Prevent token exfiltration via poisoned BASE_URL (SSRF / credential leak). */
+export function assertSafeApiBaseUrl(raw: string): string {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Invalid ANTIGRAVITY_BASE_URL: ${raw}`);
+  }
+  if (url.protocol !== "https:") {
+    throw new Error(`ANTIGRAVITY_BASE_URL must use https (got ${url.protocol})`);
+  }
+  if (url.username || url.password) {
+    throw new Error("ANTIGRAVITY_BASE_URL must not include credentials");
+  }
+  const host = url.hostname.toLowerCase();
+  const allowed =
+    host === "googleapis.com" || ALLOWED_API_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix));
+  if (!allowed) {
+    throw new Error(
+      `ANTIGRAVITY_BASE_URL host "${host}" is not allowed. Use a *.googleapis.com endpoint.`,
+    );
+  }
+  const path = url.pathname.replace(/\/+$/, "");
+  return `${url.origin}${path === "/" ? "" : path}`;
+}
+
+/** Redact bearer tokens, refresh tokens, and similar secrets from diagnostics/errors. */
+export function redactSecrets(text: string): string {
+  return text
+    .replace(/\bya29\.[A-Za-z0-9._~+/-]+=*/g, "[redacted-access-token]")
+    .replace(/\b1\/[A-Za-z0-9_-]{20,}/g, "[redacted-refresh-token]")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [redacted]")
+    .replace(
+      /("?(?:access_token|refresh_token|id_token|token|client_secret|code_verifier|authorization)"?\s*[:=]\s*")[^"]*(")/gi,
+      "$1[redacted]$2",
+    )
+    .replace(
+      /("?(?:access_token|refresh_token|id_token|token|client_secret|code_verifier|authorization)"?\s*[:=]\s*)[^\s&,}]+/gi,
+      "$1[redacted]",
+    );
+}
+
+export function maskEmail(email: string | undefined): string | undefined {
+  if (!email || typeof email !== "string") return undefined;
+  const parts = email.split("@");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return "[redacted-email]";
+  const name = parts[0];
+  const domain = parts[1];
+  const lastChar = name.at(-1) || "";
+  const maskedName = name.length > 2 ? `${name[0]}***${lastChar}` : `${name[0]}***`;
+  return `${maskedName}@${domain}`;
+}
+
+export function safeError(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  return redactSecrets(raw);
+}

package/node_modules/pi-antigravity/src/utils/util.ts

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { getModelEnum } from "../models/models.js";
+
+export function antigravityEnv(name: string): string | undefined {
+  return process.env[`ANTIGRAVITY_${name}`] || process.env[`NOAGY_${name}`];
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export function sanitizeText(text: unknown): string {
+  return String(text ?? "").replace(/[\uD800-\uDFFF]/g, "\uFFFD");
+}
+
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+export function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function nowRequestId(): string {
+  return antigravityRequestEnvelope("unknown", false).requestId;
+}
+
+/** Deterministic RFC 4122 v5 UUID from seed (survives restarts for the same session seed). */
+export function stableUuid(seed: string): string {
+  const bytes = createHash("sha1").update(seed).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+export type AntigravityEnvelopeOptions = {
+  isClaude?: boolean;
+  isNonGemini?: boolean;
+  step?: number;
+  lastStepIndex?: string;
+  requestIndex?: number;
+  userTurnIndex?: number;
+  trajectoryId?: string;
+  conversationId?: string;
+};
+
+const sessionTrajectoryMap = new Map<string, { conversationId: string; trajectoryId: string }>();
+
+/** Stable conversationId and trajectoryId within a multi-turn conversation session. */
+export function resolveSessionTrajectory(context?: {
+  messages?: Array<{ role?: string; timestamp?: number; content?: unknown }>;
+}): { conversationId: string; trajectoryId: string } {
+  const firstMsg = context?.messages?.[0];
+  if (!firstMsg) {
+    return { conversationId: crypto.randomUUID(), trajectoryId: crypto.randomUUID() };
+  }
+  const contentSeed =
+    typeof firstMsg.content === "string"
+      ? firstMsg.content.slice(0, 64)
+      : Array.isArray(firstMsg.content)
+        ? JSON.stringify(firstMsg.content[0] ?? "").slice(0, 64)
+        : "";
+  const seed = `${firstMsg.role || "user"}:${firstMsg.timestamp || ""}:${contentSeed}`;
+  let entry = sessionTrajectoryMap.get(seed);
+  if (!entry) {
+    entry = {
+      conversationId: stableUuid(`antigravity:conv:${seed}`),
+      trajectoryId: stableUuid(`antigravity:traj:${seed}`),
+    };
+    sessionTrajectoryMap.set(seed, entry);
+    if (sessionTrajectoryMap.size > 64) {
+      const oldestKey = sessionTrajectoryMap.keys().next().value;
+      if (oldestKey !== undefined) sessionTrajectoryMap.delete(oldestKey);
+    }
+  }
+  return entry;
+}
+
+export function clearSessionTrajectoryMap(): void {
+  sessionTrajectoryMap.clear();
+}
+
+export function antigravityRequestEnvelope(
+  wireModelId: string,
+  optionsOrIsClaude: boolean | AntigravityEnvelopeOptions = false,
+): { requestId: string; sessionId: string; labels: Record<string, string> } {
+  const options: AntigravityEnvelopeOptions =
+    typeof optionsOrIsClaude === "boolean" ? { isClaude: optionsOrIsClaude } : optionsOrIsClaude;
+
+  const isClaude = Boolean(options.isClaude);
+  const isNonGemini = Boolean(options.isNonGemini || isClaude);
+  const step = Math.max(1, options.step ?? 1);
+  const lastStepIndex = options.lastStepIndex ?? String(Math.max(0, step - 1));
+  const requestIndex = options.requestIndex ?? options.userTurnIndex ?? Math.max(0, step - 1);
+  const agentId = options.conversationId || crypto.randomUUID();
+  const trajectoryId = options.trajectoryId || crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(8));
+  const sessionId = String(new DataView(bytes.buffer, bytes.byteOffset, 8).getBigInt64(0, true));
+
+  const claudeLabel = isClaude ? "true" : "false";
+  const nonGeminiLabel = isNonGemini ? "true" : "false";
+
+  const labels: Record<string, string> = {
+    last_step_index: lastStepIndex,
+    request_id: `${trajectoryId}-${requestIndex}`,
+    trajectory_id: trajectoryId,
+    used_claude: claudeLabel,
+    used_claude_conservative: claudeLabel,
+    used_non_gemini_model: nonGeminiLabel,
+  };
+
+  const modelEnum = getModelEnum(wireModelId);
+  if (modelEnum) {
+    labels.model_enum = modelEnum;
+  }
+
+  return {
+    requestId: `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`,
+    sessionId,
+    labels,
+  };
+}

package/node_modules/pi-antigravity/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-extensions",
-  "version": "2026.9.3",
+  "version": "2026.9.4",
   "description": "Aggregate installer for HerbertGao-maintained Pi extensions.",
   "keywords": [
     "extensions",
@@ -44,7 +44,7 @@
     "@effect/platform-node": "4.0.0-beta.103",
     "@effect/platform-node-shared": "4.0.0-beta.103",
     "@herbertgao/pi-bark": "0.1.0",
-    "@herbertgao/pi-cc-extensions": "0.9.0",
+    "@herbertgao/pi-cc-extensions": "0.9.1",
     "@herbertgao/pi-subagents": "0.17.1",
     "@herbertgao/resume-from": "0.2.0",
     "@herbertgao/sol-pi": "0.2.0",
@@ -90,6 +90,7 @@
     "nanoid": "^5.0.0",
     "open": "^10.2.0",
     "p-limit": "^6.1.0",
+    "pi-antigravity": "0.7.2",
     "pi-footer": "0.5.1",
     "pi-lens": "4.1.6",
     "pi-mcp-adapter": "2.32.1",
@@ -133,6 +134,7 @@
     "@tifan/pi-preferred-thinking",
     "@tifan/pi-recap",
     "@tifan/pi-rename",
+    "pi-antigravity",
     "pi-footer",
     "pi-lens",
     "pi-mcp-adapter",
@@ -166,6 +168,7 @@
       "./node_modules/pi-mcp-adapter/index.ts",
       "./node_modules/pi-lens/dist/index.js",
       "./node_modules/pi-web-access/index.ts",
+      "./node_modules/pi-antigravity/src/index.ts",
       "./node_modules/remote-pi/dist/index.js",
       "./node_modules/@czottmann/pi-automode/extensions/auto-mode.ts",
       "./node_modules/pi-footer/src/index.ts"