UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

235 lines (221 loc) • 10.7 kB
import { getConfigDir } from "../../config/paths"; import { isTelemetryEnvOptOut } from "../consent"; import { formatUtcDay } from "../state"; import { aggregateTelemetryForDay } from "../aggregate"; import { createProfile, deleteProfile, fetchOwnProfileRank, type ProfileClientOptions } from "./client"; import { PROFILE_SCHEMA_VERSION, validateProfileCreateV1, type ProfileDayV1, type ProfileRankV1, } from "./contract"; import { deleteTelemetryProfileFile, readTelemetryProfileFile, toPublicProfileState, writeTelemetryProfileState, type TelemetryProfilePublicState, } from "./state"; import { buildProfileDay, readProfileTelemetryGate, resolveNextProfileDay } from "./sync"; export type ProfileErrorCode = | "telemetry_off" | "already_connected" | "deletion_pending" | "invalid" | "handle_taken" | "rate_limited" | "collector_unavailable" | "not_connected" | "profile_unreadable"; export class ProfileActionError extends Error { constructor(readonly code: ProfileErrorCode, message: string, readonly status: number) { super(message); this.name = "ProfileActionError"; } } export interface ProfileStatusSnapshot { connected: boolean; /** The file exists but cannot be read: nothing is sent; disconnect is still offered. */ unreadable: boolean; profile: TelemetryProfilePublicState | null; /** Anonymous telemetry is effectively on (required for connecting and for sending). */ telemetryEffective: boolean; nextDay: string | null; nextDayReason: string; /** Exactly what the next send would contain, or null. */ preview: ProfileDayV1 | null; } export interface ProfileServiceOptions extends ProfileClientOptions { configDir?: string; now?: number; env?: Record<string, string | undefined>; } const PREVIEW_CACHE_MS = 10 * 60 * 1000; let previewCache: { configDir: string; connectedAt: string; day: string; at: number; preview: ProfileDayV1 | null } | null = null; const RANK_CACHE_MS = 5 * 60 * 1000; let rankCache: { configDir: string; handle: string; at: number; rank: ProfileRankV1 } | null = null; export function resetProfileServiceCachesForTests(): void { previewCache = null; rankCache = null; } export async function buildProfileStatusSnapshot( options: ProfileServiceOptions & { cachePreview?: boolean } = {}, ): Promise<ProfileStatusSnapshot> { const configDir = options.configDir ?? getConfigDir(); const now = options.now ?? Date.now(); const env = options.env ?? process.env; const gate = readProfileTelemetryGate({ configDir, env }); const telemetryEffective = gate.status.effective && isTelemetryEnvOptOut(env) === null; const file = readTelemetryProfileFile(configDir); const base = { connected: file.state !== null, unreadable: file.unreadable, telemetryEffective }; if (!file.state) { return { ...base, profile: null, nextDay: null, nextDayReason: file.unreadable ? "state-unreadable" : "not-connected", preview: null }; } const profile = file.state; const next = profile.pendingDelete ? { day: null, reason: "deletion-pending" } : profile.revoked ? { day: null, reason: "revoked" } : resolveNextProfileDay(profile, gate, now); let preview: ProfileDayV1 | null = null; if (next.day) { const hit = previewCache; if (options.cachePreview && hit && hit.configDir === configDir && hit.connectedAt === profile.connectedAt && hit.day === next.day && now - hit.at >= 0 && now - hit.at < PREVIEW_CACHE_MS) { preview = hit.preview; } else { preview = buildProfileDay(await aggregateTelemetryForDay(next.day)); if (options.cachePreview) previewCache = { configDir, connectedAt: profile.connectedAt, day: next.day, at: now, preview }; } } return { ...base, profile: toPublicProfileState(profile), nextDay: next.day, nextDayReason: next.reason, preview }; } export interface ConnectProfileInput { handle: unknown; displayName: unknown; avatar: unknown; } /** * Create the public profile and store its secret. Callers have already established that a person * asked for this (a human dashboard session or an interactive, non-agent terminal). */ export async function connectTelemetryProfile( input: ConnectProfileInput, options: ProfileServiceOptions = {}, ): Promise<TelemetryProfilePublicState> { const configDir = options.configDir ?? getConfigDir(); const now = options.now ?? Date.now(); const env = options.env ?? process.env; const existing = readTelemetryProfileFile(configDir); if (existing.unreadable) { throw new ProfileActionError( "profile_unreadable", "The local profile file cannot be read. Remove it first with 'ocx telemetry profile disconnect' (or Disconnect on the dashboard Home).", 409, ); } if (existing.state?.pendingDelete) throw new ProfileActionError("deletion_pending", "The previous profile is still being deleted; try again once deletion is confirmed.", 409); if (existing.state) throw new ProfileActionError("already_connected", "A public profile is already connected; disconnect it first.", 409); const gate = readProfileTelemetryGate({ configDir, env }); if (!gate.status.effective || isTelemetryEnvOptOut(env) !== null) { throw new ProfileActionError("telemetry_off", "A public profile needs anonymous telemetry to be on: its totals come from the same daily aggregate.", 409); } const validated = validateProfileCreateV1({ schemaVersion: PROFILE_SCHEMA_VERSION, handle: input.handle, displayName: input.displayName, avatar: input.avatar, }); if (!validated.ok) throw new ProfileActionError("invalid", validated.error, 400); const created = await createProfile(validated.value, options); if (!created.ok) { if (created.status === 409) throw new ProfileActionError("handle_taken", "That handle is already taken.", 409); if (created.status === 400) throw new ProfileActionError("invalid", created.error, 400); if (created.status === 429) throw new ProfileActionError("rate_limited", "Too many profiles were created from this network recently; try again later.", 429); throw new ProfileActionError("collector_unavailable", "The telemetry service could not be reached; nothing was saved.", 502); } // Another connect may have finished while this one waited on the collector. const raced = readTelemetryProfileFile(configDir); if (raced.state || raced.unreadable) { await deleteProfile(created.body.secret, options); throw new ProfileActionError("already_connected", "A public profile is already connected; disconnect it first.", 409); } const state = { version: 1 as const, handle: validated.value.handle, displayName: validated.value.displayName, avatar: validated.value.avatar, secret: created.body.secret, connectedAt: new Date(now).toISOString(), // The collector refuses days on or before its own creation day; never start below it. connectedDay: created.body.createdDay && created.body.createdDay > formatUtcDay(now) ? created.body.createdDay : formatUtcDay(now), sentDays: {}, lastSentDay: null, lastSentAt: null, retryAfterUntil: null, pendingDelete: false, revoked: false, }; writeTelemetryProfileState(state, configDir, now); rankCache = null; previewCache = null; return toPublicProfileState(state); } export type DisconnectOutcome = | { status: "deleted" } | { status: "not_connected" } | { status: "local_removed" } | { status: "deletion_pending"; error: string }; /** * Disconnect: mark the deletion as pending, ask the collector to delete the profile and every row, * and remove the local file once it confirms. Never gated: leaving is always allowed, with * anonymous telemetry on or off. A deletion that cannot reach the collector stays pending and the * proxy's profile loop retries it. */ export async function disconnectTelemetryProfile(options: ProfileServiceOptions = {}): Promise<DisconnectOutcome> { const configDir = options.configDir ?? getConfigDir(); const now = options.now ?? Date.now(); const file = readTelemetryProfileFile(configDir); if (file.unreadable) { // Its secret cannot be read, so the server profile cannot be deleted from here; removing the // local file is still the person's way out. A profile that stops submitting is pruned by the // collector after 400 days and drops out of every ranked period at once. if (!deleteTelemetryProfileFile(configDir)) { throw new ProfileActionError("profile_unreadable", "The local profile file cannot be read or removed (it may be a symlink or a directory).", 409); } rankCache = null; return { status: "local_removed" }; } const state = file.state; if (!state) return { status: "not_connected" }; if (!state.pendingDelete) writeTelemetryProfileState({ ...state, pendingDelete: true, retryAfterUntil: null }, configDir, now); rankCache = null; previewCache = null; const result = await deleteProfile(state.secret, options); if (result.deleted) { if (deleteTelemetryProfileFile(configDir)) return { status: "deleted" }; // The server profile is gone, but the local file (with its now useless secret) is still // there: say so instead of reporting a clean disconnect. The loop keeps retrying the removal. return { status: "deletion_pending", error: "the local profile file could not be removed" }; } return { status: "deletion_pending", error: result.error ?? "collector unavailable" }; } /** The connected profile's ranks, from the collector, cached for a few minutes. */ export async function fetchConnectedProfileRank( options: ProfileServiceOptions = {}, ): Promise<{ ok: true; rank: ProfileRankV1 } | { ok: false; code: ProfileErrorCode | "revoked"; error: string }> { const configDir = options.configDir ?? getConfigDir(); const now = options.now ?? Date.now(); const file = readTelemetryProfileFile(configDir); if (!file.state || file.state.pendingDelete) return { ok: false, code: "not_connected", error: "No public profile is connected." }; const hit = rankCache; if (hit && hit.configDir === configDir && hit.handle === file.state.handle && now - hit.at >= 0 && now - hit.at < RANK_CACHE_MS) { return { ok: true, rank: hit.rank }; } const result = await fetchOwnProfileRank(file.state.secret, options); if (!result.ok) { if (result.status === 401) return { ok: false, code: "revoked", error: "The telemetry service no longer knows this profile." }; return { ok: false, code: "collector_unavailable", error: "Rank is unavailable right now." }; } rankCache = { configDir, handle: file.state.handle, at: now, rank: result.body }; return { ok: true, rank: result.body }; }