letmecode 0.1.19 → 0.1.21

package/ink-app/dist/providers/antigravity/quota-parser.js

@@ -0,0 +1,49 @@
+const QUOTA_WINDOWS = {
+    "5h": {
+        scope: "primary",
+        windowMinutes: 300
+    },
+    weekly: {
+        scope: "secondary",
+        windowMinutes: 10080
+    }
+};
+export function parseAntigravityQuotaEntries(groups) {
+    return groups.flatMap((group) => {
+        const modelScope = resolveQuotaGroupScope(`${group.displayName ?? ""} ${group.description ?? ""}`);
+        if (!modelScope) {
+            return [];
+        }
+        return (group.buckets ?? []).flatMap((bucket) => {
+            const window = bucket.window
+                ? QUOTA_WINDOWS[bucket.window]
+                : undefined;
+            const resetAt = Date.parse(bucket.resetTime ?? "");
+            if (!bucket.bucketId ||
+                window === undefined ||
+                !Number.isFinite(resetAt) ||
+                typeof bucket.remainingFraction !== "number" ||
+                bucket.remainingFraction < 0 ||
+                bucket.remainingFraction > 1) {
+                return [];
+            }
+            return [{
+                    limitId: bucket.bucketId,
+                    modelScope,
+                    remainingFraction: bucket.remainingFraction,
+                    resetAt,
+                    ...window
+                }];
+        });
+    });
+}
+function resolveQuotaGroupScope(text) {
+    const normalized = text.toLowerCase();
+    if (/gemini/.test(normalized)) {
+        return "gemini";
+    }
+    if (/claude|gpt/.test(normalized)) {
+        return "third-party";
+    }
+    return null;
+}

package/ink-app/dist/providers/antigravity/rpc/client.js

@@ -0,0 +1,54 @@
+import https from "node:https";
+export const ANTIGRAVITY_RPC_PATHS = {
+    quotaSummary: "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+    userStatus: "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+    trajectories: "/exa.language_server_pb.LanguageServerService/GetAllCascadeTrajectories",
+    trajectorySteps: "/exa.language_server_pb.LanguageServerService/GetCascadeTrajectorySteps"
+};
+export async function rpc(server, endpoint, payload) {
+    const body = JSON.stringify(payload ?? {});
+    return new Promise((resolve, reject) => {
+        const request = https.request({
+            hostname: "127.0.0.1",
+            port: server.port,
+            path: endpoint,
+            method: "POST",
+            rejectUnauthorized: false,
+            timeout: 5000,
+            headers: {
+                "X-Codeium-Csrf-Token": server.csrfToken,
+                "Content-Type": "application/json",
+                "Connect-Protocol-Version": "1",
+                "Content-Length": Buffer.byteLength(body)
+            }
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            response.on("end", () => {
+                const responseBody = Buffer.concat(chunks).toString("utf8");
+                if (response.statusCode === undefined ||
+                    response.statusCode >= 300) {
+                    reject(new Error(`Antigravity RPC ${endpoint} failed with status ${response.statusCode ?? "unknown"}.`));
+                    return;
+                }
+                if (!responseBody) {
+                    resolve({});
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(responseBody));
+                }
+                catch (error) {
+                    reject(new Error(`Antigravity RPC ${endpoint} returned invalid JSON.`, { cause: error }));
+                }
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error(`Antigravity RPC ${endpoint} timed out.`));
+        });
+        request.on("error", reject);
+        request.end(body);
+    });
+}

package/ink-app/dist/providers/antigravity/rpc/discovery.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { ANTIGRAVITY_RPC_PATHS, rpc } from "./client.js";
+const execFileAsync = promisify(execFile);
+export async function findAntigravityLocalServer() {
+    const processes = await findAntigravityProcesses();
+    if (processes.length === 0) {
+        return null;
+    }
+    const portsByPid = await readListeningPortsByPid();
+    for (const process of processes) {
+        for (const port of portsByPid.get(process.pid) ?? []) {
+            const server = {
+                port,
+                csrfToken: process.csrfToken
+            };
+            try {
+                const quotaSummary = await rpc(server, ANTIGRAVITY_RPC_PATHS.quotaSummary);
+                return { server, quotaSummary };
+            }
+            catch {
+                // This port does not expose the expected Antigravity RPC API.
+            }
+        }
+    }
+    return null;
+}
+async function findAntigravityProcesses() {
+    const entries = await fs.promises
+        .readdir("/proc")
+        .catch(() => []);
+    const processes = [];
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry)) {
+            continue;
+        }
+        const args = await fs.promises
+            .readFile(`/proc/${entry}/cmdline`, "utf8")
+            .then((value) => value.split("\0").filter(Boolean))
+            .catch(() => []);
+        const command = args.join(" ").toLowerCase();
+        if (!command.includes("antigravity") ||
+            !/(language|extension)[_-]server/.test(command)) {
+            continue;
+        }
+        const inlineToken = args.find((arg) => arg.startsWith("--csrf_token="));
+        const tokenIndex = args.indexOf("--csrf_token");
+        const csrfToken = inlineToken?.slice("--csrf_token=".length) ??
+            (tokenIndex >= 0 ? args[tokenIndex + 1] : undefined);
+        if (!csrfToken) {
+            continue;
+        }
+        processes.push({
+            pid: Number(entry),
+            csrfToken
+        });
+    }
+    return processes;
+}
+async function readListeningPortsByPid() {
+    const { stdout } = await execFileAsync("ss", ["-H", "-ltnp"], {
+        encoding: "utf8",
+        timeout: 5000
+    });
+    const portsByPid = new Map();
+    for (const line of stdout.split("\n")) {
+        const loopbackPorts = [
+            ...line.matchAll(/(?:127\.0\.0\.1|\[::1\]):(\d+)/g)
+        ].map((match) => Number(match[1]));
+        if (loopbackPorts.length === 0) {
+            continue;
+        }
+        for (const pidMatch of line.matchAll(/pid=(\d+),/g)) {
+            const pid = Number(pidMatch[1]);
+            const ports = portsByPid.get(pid) ?? new Set();
+            for (const port of loopbackPorts) {
+                ports.add(port);
+            }
+            portsByPid.set(pid, ports);
+        }
+    }
+    return new Map([...portsByPid.entries()].map(([pid, ports]) => [pid, [...ports]]));
+}

package/ink-app/dist/providers/antigravity/rpc/quota.js

@@ -0,0 +1,25 @@
+import { ANTIGRAVITY_RPC_PATHS, rpc } from "./client.js";
+import { asRecord } from "../../limits.js";
+const METADATA = {
+    ideName: "antigravity",
+    extensionName: "antigravity",
+    ideVersion: "unknown",
+    locale: "en"
+};
+/**
+ * Pulls the raw quota groups out of a RetrieveUserQuotaSummary payload.
+ * Validation and normalization are the parser's responsibility, so this only
+ * unwraps the envelope.
+ */
+export function extractQuotaGroups(payload) {
+    const response = asRecord(asRecord(payload)?.response);
+    const groups = response?.groups;
+    return Array.isArray(groups) ? groups : [];
+}
+export async function fetchAntigravityUserStatus(server) {
+    const status = await rpc(server, ANTIGRAVITY_RPC_PATHS.userStatus, { metadata: METADATA }).catch(() => null);
+    return {
+        email: status?.userStatus?.email ?? null,
+        planName: status?.userStatus?.planStatus?.planInfo?.planName ?? null
+    };
+}

package/ink-app/dist/providers/antigravity/rpc/usage.js

@@ -0,0 +1,80 @@
+import { ANTIGRAVITY_RPC_PATHS, rpc } from "./client.js";
+const TRAJECTORY_METADATA = {
+    ideName: "antigravity",
+    extensionName: "antigravity"
+};
+const STEPS_CONCURRENCY = 8;
+/**
+ * Reconstructs per-response model usage from the Antigravity local language
+ * server.
+ *
+ * Every billable model call is recorded on a trajectory step as
+ * `metadata.modelUsage`, identified by `responseId`, and usage is spread across
+ * several step types (planner responses, checkpoints, ...). This reads every
+ * step rather than filtering by type. `GetCascadeTrajectorySteps` returns the
+ * full step list for a cascade in one response, so each cascade is fetched
+ * once, and cascades are fetched concurrently. De-duplication of responses is
+ * the caller's responsibility.
+ */
+export async function fetchAntigravityUsageRpcData(server) {
+    const trajectories = await rpc(server, ANTIGRAVITY_RPC_PATHS.trajectories, {
+        metadata: TRAJECTORY_METADATA
+    });
+    const cascades = Object.entries(trajectories.trajectorySummaries ?? {})
+        .map(([cascadeId, summary]) => ({
+        cascadeId,
+        stepCount: summary.stepCount ?? 0
+    }))
+        .filter((cascade) => cascade.stepCount > 0);
+    const perCascade = await mapWithConcurrency(cascades, STEPS_CONCURRENCY, (cascade) => fetchCascadeUsage(server, cascade.cascadeId, cascade.stepCount));
+    return perCascade.flat();
+}
+async function fetchCascadeUsage(server, cascadeId, stepCount) {
+    const response = await rpc(server, ANTIGRAVITY_RPC_PATHS.trajectorySteps, {
+        cascadeId,
+        startIndex: 0,
+        endIndex: stepCount
+    });
+    const usage = [];
+    for (const step of response.steps ?? []) {
+        const modelUsage = step.metadata?.modelUsage;
+        const created = step.metadata?.createdAt;
+        const responseId = modelUsage?.responseId;
+        const model = modelUsage?.model;
+        if (!modelUsage || !created || !responseId || !model) {
+            continue;
+        }
+        usage.push({
+            responseId,
+            cascadeId,
+            created,
+            model,
+            input: toTokenCount(modelUsage.inputTokens),
+            output: toTokenCount(modelUsage.outputTokens),
+            cacheRead: toTokenCount(modelUsage.cacheReadTokens),
+            reasoning: toTokenCount(modelUsage.thinkingOutputTokens)
+        });
+    }
+    return usage;
+}
+function toTokenCount(value) {
+    const parsed = typeof value === "string" ? Number(value) : value;
+    return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : 0;
+}
+async function mapWithConcurrency(items, limit, task) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    const workerCount = Math.max(1, Math.min(limit, items.length));
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await task(items[index]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/ink-app/dist/providers/antigravity/types.js

@@ -0,0 +1 @@
+export {};

package/ink-app/dist/providers/antigravity/usage-parse.js

@@ -0,0 +1,23 @@
+import { fetchAntigravityUsageRpcData } from "./rpc/usage.js";
+export async function collectUsageFromLocalRpc(server, options) {
+    const usage = await fetchAntigravityUsageRpcData(server);
+    options?.traceLogger?.log(`[Antigravity] usage: ${JSON.stringify(usage, null, 2)}`);
+    return usage.flatMap((entry) => {
+        const timestamp = Date.parse(entry.created);
+        if (!Number.isFinite(timestamp)) {
+            return [];
+        }
+        return [{
+                type: "usage",
+                sessionId: entry.cascadeId,
+                responseId: entry.responseId,
+                timestamp,
+                modelId: entry.model,
+                input: entry.input,
+                cacheRead: entry.cacheRead,
+                cacheWrite: 0,
+                output: entry.output,
+                reasoning: entry.reasoning
+            }];
+    });
+}