@centerforagenticai/pi-multi-account 0.1.1

package/packages/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/scripts/multi-account.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// The published `multi-account` bin entry.
+//
+// This package ships raw TypeScript (see `package.json`'s `"exports":
+// "./src/index.ts"`); it is never compiled to `dist/*.js`. Every module under
+// `src/` uses NodeNext-style relative specifiers -- `import "./config.js"` --
+// that point at a ".ts" sibling, exactly as `tsc -p tsconfig.json` requires.
+// The Pi coding-agent host and Vitest both already know how to resolve that;
+// a bare `node` invocation of this standalone launcher does not, and this
+// package intentionally carries no `tsx`/`ts-node`-class dependency.
+//
+// So this file installs a small, synchronous Node module-customization hook
+// (see https://nodejs.org/api/module.html#module-registerhooksoptions) that
+// redirects a relative ".js" specifier to its ".ts" sibling when one exists,
+// then hands off to `runStandaloneCli`. `module.registerHooks()` installs
+// in-thread and takes effect immediately for every module resolution issued
+// afterward in this same realm -- including this file's own dynamic import
+// below -- so, unlike the async, loader-thread `module.register()` API this
+// replaced, no `--import` preload and no re-exec are needed to avoid a race
+// against that import. (`module.register()` also emits Node's DEP0205
+// deprecation warning to stderr as of Node 26, which broke this CLI's
+// documented empty-stderr contract on a clean run; `registerHooks()` has no
+// such warning on any currently supported Node major.)
+import { registerHooks } from "node:module";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (specifier.startsWith(".") && specifier.endsWith(".js")) {
+			try {
+				return nextResolve(specifier.replace(/\.js$/, ".ts"), context);
+			} catch {
+				// No ".ts" sibling: fall through to normal resolution below, which
+				// will raise Node's own not-found error for a genuinely missing
+				// specifier.
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+});
+
+const { runStandaloneCli } = await import(
+	new URL("../src/standalone-cli.ts", import.meta.url)
+);
+process.exitCode = await runStandaloneCli(process.argv.slice(2));

package/src/account-labels.ts

@@ -0,0 +1,223 @@
+/**
+ * Human-meaningful identity for managed accounts.
+ *
+ * Pi renders a provider's `name` in the login list, falling back to the OAuth
+ * method name. Because the Anthropic alias inherits the upstream OAuth config
+ * verbatim, every managed Anthropic account previously rendered as the same
+ * "Claude Pro/Max" string, leaving an operator unable to tell which account to
+ * log in to or refresh.
+ *
+ * This module resolves a bounded, display-safe label per provider id. It is
+ * presentation-only: it performs no I/O, mutates no routing state, and never
+ * retains credential material.
+ */
+
+import {
+	classifyProviderId,
+	isProviderSlotWithinAccountLimit,
+} from "./discovery.js";
+
+/** Hard cap on a rendered label; derived values are truncated to fit. */
+const MAX_LABEL_LENGTH = 64;
+
+/**
+ * Printable ASCII excluding control characters. Labels reach a terminal UI, so
+ * anything that could smuggle escape sequences is rejected outright rather
+ * than escaped.
+ */
+const DISPLAY_SAFE = /^[\x20-\x7E]+$/;
+
+/** Claim names that may carry a human-identifying value, in priority order. */
+const IDENTITY_CLAIMS = ["email", "preferred_username", "name"] as const;
+
+/** Bounded per-account label overrides, keyed by canonical provider id. */
+export type AccountLabelConfig = Readonly<Record<string, string>>;
+
+/**
+ * Normalizes an operator-supplied or derived label. Returns undefined when the
+ * value is absent, empty, unsafe to display, or not a string — callers then
+ * fall back rather than surfacing a partial or hostile value.
+ */
+export function normalizeLabel(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return undefined;
+	if (!DISPLAY_SAFE.test(trimmed)) return undefined;
+	return trimmed.length > MAX_LABEL_LENGTH
+		? trimmed.slice(0, MAX_LABEL_LENGTH)
+		: trimmed;
+}
+
+/**
+ * Extracts a human-identifying claim from a JWT-shaped access token.
+ *
+ * Only the payload segment is decoded, and only an allow-listed identity claim
+ * is read; the signature, header, and every other claim are discarded. A
+ * malformed, oversized, non-JWT, or unparseable token yields undefined rather
+ * than throwing, so a hostile credential can never break registration or leak
+ * token content into a label.
+ *
+ * Anthropic credentials are opaque and will always return undefined here; they
+ * rely on configured labels instead.
+ */
+export function deriveLabelFromToken(token: unknown): string | undefined {
+	if (typeof token !== "string") return undefined;
+	// Bound the work: real access tokens are small, and this refuses to parse
+	// arbitrarily large strings.
+	if (token.length === 0 || token.length > 8_192) return undefined;
+	const segments = token.split(".");
+	if (segments.length !== 3) return undefined;
+	const payloadSegment = segments[1];
+	if (payloadSegment === undefined || payloadSegment.length === 0) {
+		return undefined;
+	}
+	let payload: unknown;
+	try {
+		const decoded = Buffer.from(payloadSegment, "base64url").toString("utf8");
+		if (decoded.length === 0 || decoded.length > 8_192) return undefined;
+		payload = JSON.parse(decoded);
+	} catch {
+		return undefined;
+	}
+	if (typeof payload !== "object" || payload === null) return undefined;
+	const record = payload as Record<string, unknown>;
+	for (const claim of IDENTITY_CLAIMS) {
+		const label = normalizeLabel(record[claim]);
+		if (label !== undefined) return label;
+	}
+	// Some providers nest identity under a namespaced profile object.
+	for (const value of Object.values(record)) {
+		if (typeof value !== "object" || value === null) continue;
+		const nested = value as Record<string, unknown>;
+		for (const claim of IDENTITY_CLAIMS) {
+			const label = normalizeLabel(nested[claim]);
+			if (label !== undefined) return label;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * A stable fingerprint identifying the real account behind a credential.
+ *
+ * Detects one account occupying two slots, where failover between them is
+ * decorative: they share a single quota and rate limit. Codex tokens are JWTs
+ * carrying a stable subject claim, so the fingerprint survives token refresh.
+ * Anthropic tokens are opaque and yield undefined, which callers must treat as
+ * "unknown" rather than "different account".
+ */
+export function accountFingerprint(token: unknown): string | undefined {
+	if (typeof token !== "string" || token.length === 0) return undefined;
+	if (token.length > 8_192) return undefined;
+	const segments = token.split(".");
+	if (segments.length !== 3) return undefined;
+	const payloadSegment = segments[1];
+	if (payloadSegment === undefined || payloadSegment.length === 0) {
+		return undefined;
+	}
+	let payload: unknown;
+	try {
+		const decoded = Buffer.from(payloadSegment, "base64url").toString("utf8");
+		if (decoded.length === 0 || decoded.length > 8_192) return undefined;
+		payload = JSON.parse(decoded);
+	} catch {
+		return undefined;
+	}
+	if (typeof payload !== "object" || payload === null) return undefined;
+	const subject = (payload as Record<string, unknown>)["sub"];
+	if (typeof subject === "string" && subject.length > 0) return subject;
+	return deriveLabelFromToken(token);
+}
+
+/**
+ * Groups managed slots that resolve to the SAME underlying account.
+ *
+ * Returns one entry per duplicated account listing the provider ids sharing it.
+ * Slots whose identity cannot be determined are never grouped, so an
+ * opaque-token family produces no false positives.
+ */
+export function duplicateAccountGroups(
+	slots: ReadonlyArray<{
+		readonly providerId: string;
+		readonly token?: unknown;
+	}>,
+): ReadonlyArray<readonly string[]> {
+	const byFingerprint = new Map<string, string[]>();
+	for (const { providerId, token } of slots) {
+		const fingerprint = accountFingerprint(token);
+		if (fingerprint === undefined) continue;
+		const group = byFingerprint.get(fingerprint);
+		if (group) group.push(providerId);
+		else byFingerprint.set(fingerprint, [providerId]);
+	}
+	return [...byFingerprint.values()].filter((group) => group.length > 1);
+}
+
+/**
+ * Resolves the label for one managed account.
+ *
+ * Precedence is deliberate: an explicitly configured label always wins, because
+ * the operator's own naming convention is more meaningful than any value the
+ * provider happens to embed. A derived label is the fallback, and the canonical
+ * provider id is the final backstop so registration never fails for want of a
+ * name.
+ */
+export function resolveAccountLabel(input: {
+	readonly providerId: string;
+	readonly configured?: AccountLabelConfig | undefined;
+	readonly token?: unknown;
+}): string {
+	const configured = normalizeLabel(input.configured?.[input.providerId]);
+	if (configured !== undefined) return configured;
+	const derived = deriveLabelFromToken(input.token);
+	if (derived !== undefined) return derived;
+	return input.providerId;
+}
+
+/**
+ * Resolves a managed account's label only when its provider id is within the
+ * current validated account limit.
+ *
+ * This is the final label sink's own guard. It classifies `input.providerId`,
+ * applies `isProviderSlotWithinAccountLimit(slot, input.accountLimit)`, and
+ * returns the original provider id before indexing `configured` or invoking the
+ * lazy `readToken` callback when the id is malformed or out of the current
+ * limit. Only an in-range managed id reaches {@link resolveAccountLabel}. It
+ * closes the label boundary independently rather than trusting every future
+ * caller to remember an upstream projection.
+ */
+export function resolveAccountLabelWithinLimit(input: Readonly<{
+	providerId: string;
+	accountLimit: number;
+	configured: AccountLabelConfig;
+	readToken: (providerId: string) => unknown;
+}>): string {
+	const slot = classifyProviderId({
+		providerId: input.providerId,
+		credentialType: "unknown",
+	});
+	if (
+		slot === null ||
+		!isProviderSlotWithinAccountLimit(slot, input.accountLimit)
+	) return input.providerId;
+	return resolveAccountLabel({
+		providerId: input.providerId,
+		configured: input.configured,
+		token: input.readToken(input.providerId),
+	});
+}
+
+/**
+ * Composes the string Pi shows in its login list and provider UI, pairing the
+ * family's product name with the account's own label. When the label carries no
+ * information beyond the provider id, the base name is returned unadorned to
+ * avoid a redundant "Claude Pro/Max — anthropic-account-2".
+ */
+export function composeDisplayName(
+	baseName: string,
+	label: string,
+	providerId: string,
+): string {
+	if (label === providerId) return baseName;
+	return `${baseName} — ${label}`;
+}