pi-harness-runtime 1.1.397 → 1.1.402

package/scripts/unified-webhook-server.ts

@@ -21,9 +21,9 @@ import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } fr
 import { join } from "node:path";
 import { homedir } from "os";
 import { createServer, IncomingMessage, ServerResponse } from "node:http";
-import { createRelayServer } from "../packages/relay/src/server";
-import { resolveRelayEndpoint } from "../packages/relay/src/relay-endpoint";
-import { generateMessageId } from "../packages/relay/src/types";
+import { createRelayServer } from "../packages/relay/dist/server.js";
+import { resolveRelayEndpoint } from "../packages/relay/dist/relay-endpoint.js";
+import { generateMessageId } from "../packages/relay/dist/types.js";
 import type { CallbackPayload } from "../packages/relay/src/types";
 import type { RelayServerOptions } from "../packages/relay/src/server";
 // One implementation of the Telegram allow-list (env var, key file, legacy
@@ -33,6 +33,7 @@ import { getAllowedUserIds, isAuthorizedTelegramSender } from "../harness/telegr
 // /api/logs, the server queues them durably and a worker uploads them to
 // Cloudflare R2.
 import {
+	IncidentStore,
 	LogCredentialStore,
 	LogIndexStore,
 	LogIngestService,
@@ -40,7 +41,7 @@ import {
 	LogOutboxWorker,
 	createLogHttpHandler,
 	serverObjectKey,
-} from "../packages/logging/src/server/index";
+} from "../packages/logging/dist/server/index.js";
 import type { OutboxEntry } from "../packages/logging/src/server/outbox";
 import { loadR2Config, R2Client } from "./r2-storage";
 
@@ -92,6 +93,8 @@ const LOG_INGEST_DIR = join(process.env.HOME || homedir() || "/tmp", ".pi-harnes
 const LOG_OUTBOX_DIR = join(process.env.HOME || homedir() || "/tmp", ".pi-harness-runtime", "logs", "outbox");
 /** Metadata index used by the query endpoint. */
 const LOG_INDEX_DIR = join(process.env.HOME || homedir() || "/tmp", ".pi-harness-runtime", "logs", "index");
+/** Durable storage of the derived incidents, one file per tenant and day. */
+const LOG_INCIDENT_DIR = join(process.env.HOME || homedir() || "/tmp", ".pi-harness-runtime", "logs", "incidents");
 /** Largest accepted ingest body (2 MB). A batch is NDJSON, so this is generous. */
 const LOG_INGEST_MAX_BYTES = 2 * 1024 * 1024;
 /** Largest accepted query body (64 KB is plenty for a filter object). */
@@ -107,10 +110,14 @@ const LOG_QUERY_MAX_BYTES = 64 * 1024;
 const logCredentials = LogCredentialStore.load();
 const logOutbox = new LogOutbox({ dir: LOG_OUTBOX_DIR });
 const logIndex = new LogIndexStore({ dir: LOG_INDEX_DIR });
+const logIncidents = new IncidentStore({ dir: LOG_INCIDENT_DIR });
 const logService = new LogIngestService({
   credentials: logCredentials,
   outbox: logOutbox,
   index: logIndex,
+  // The derived incidents: a versioned, tenant scoped view of what is
+  // actually going wrong.
+  incidents: logIncidents,
 });
 /** The HTTP surface of the log service (ingest, query, diagnostics). */
 const logHttpHandler = createLogHttpHandler({
@@ -553,12 +560,17 @@ async function handleLINE(req: IncomingMessage, res: ServerResponse, config: Con
           queueCallback(callback);
         }
 
-        // Write to job commands file (for pi-harness HTTP polling)
-        writeJobCommand({
-          command: action,
-          jobId: targetId,
-          userId: parseInt(event.source?.userId || "0", 10) || 0,
-        });
+        // Write to job commands file (for pi-harness HTTP polling).
+        // Only the job commands belong there: an approval action resolves a
+        // pending question and travels through the callback path, so the
+        // job command queue must not receive it.
+        if (action === "resume" || action === "cancel") {
+          writeJobCommand({
+            command: action,
+            jobId: targetId,
+            userId: parseInt(event.source?.userId || "0", 10) || 0,
+          });
+        }
 
         console.log(`[LINE] Postback: ${action} ${targetId} (WS clients: ${wsCount})`);
       }

package/scripts/verify-package-contents.ts

@@ -0,0 +1,345 @@
+#!/usr/bin/env bun
+/**
+ * Verify that the published `pi-harness-runtime` package is a SINGLE, self
+ * contained app.
+ *
+ * The user installs one package:
+ *
+ *     npm install pi-harness-runtime
+ *
+ * and must get every internal app with it. The internal packages are not
+ * published on their own, so the runtime reaches them through relative paths
+ * into `packages/<name>/...`. That only works when:
+ *
+ *   1. every internal package was built (its `dist` exists), and
+ *   2. every VALUE import of the shipped runtime resolves to a file that the
+ *      build produces, and
+ *   3. the tarball that npm publishes actually contains those files.
+ *
+ * A type-only import is erased at runtime, so it may keep pointing at the
+ * source. A value import may not: `packages/<pkg>/src/<file>.js` only exists
+ * when somebody compiled the package in place, and a clean build emits into
+ * `dist/`. The published app would then fail to import it.
+ *
+ * Usage:
+ *   bun scripts/verify-package-contents.ts            # file checks
+ *   bun scripts/verify-package-contents.ts --pack     # also inspect the tarball
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { execFile, spawnSync } from "node:child_process";
+import { join, resolve, dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const verifyTarball = process.argv.includes("--pack");
+
+interface Problem {
+	kind: "missing-dist" | "missing-import" | "missing-tarball" | "missing-package";
+	detail: string;
+}
+
+const problems: Problem[] = [];
+/** Every runtime import that must resolve: "file -> specifier". */
+const runtimeImports = new Map<string, { file: string; specifier: string; target: string }>();
+
+/** Every directory whose sources are part of the published tarball. */
+const SHIPPED_SOURCE_DIRS = ["harness", "scripts", "packages"];
+
+const SHIPPED_ROOT_FILES = [
+	"index.ts",
+	"status-parsers.ts",
+	"tracker.ts",
+	"windows.ts",
+];
+
+function listFiles(dir: string, filter: (file: string) => boolean): string[] {
+	if (!existsSync(dir)) return [];
+	const out: string[] = [];
+	for (const entry of readdirSync(dir)) {
+		const full = join(dir, entry);
+		let isDir = false;
+		try {
+			isDir = statSync(full).isDirectory();
+		} catch {
+			continue;
+		}
+		if (isDir) {
+			// node_modules and the build output of a package are not sources.
+			if (entry === "node_modules" || entry === "dist" || entry === ".git") continue;
+			out.push(...listFiles(full, filter));
+		} else if (filter(full)) {
+			out.push(full);
+		}
+	}
+	return out;
+}
+
+function isSourceFile(file: string): boolean {
+	return /\.(ts|mts|cts|mjs|js)$/.test(file) && !file.endsWith(".d.ts");
+}
+
+/** Every source file that ends up in the published package. */
+function shippedSourceFiles(): string[] {
+	const files: string[] = [];
+	for (const name of SHIPPED_ROOT_FILES) {
+		const full = join(ROOT, name);
+		if (existsSync(full)) files.push(full);
+	}
+	for (const dir of SHIPPED_SOURCE_DIRS) {
+		files.push(...listFiles(join(ROOT, dir), isSourceFile));
+	}
+	return files;
+}
+
+// A value import: a static import without the `type` keyword, a dynamic
+// import or a side effect import.
+const STATIC_IMPORT = /import\s+(type\s+)?[^;]*?from\s*["']([^"']+)["']/g;
+const DYNAMIC_IMPORT = /import\s*\(\s*["']([^"']+)["']\s*\)/g;
+const SIDE_EFFECT_IMPORT = /(?:^|\n)\s*import\s*["']([^"']+)["']/g;
+
+function checkImports(): void {
+	for (const file of shippedSourceFiles()) {
+		const content = readFileSync(file, "utf8");
+		const consider = (specifier: string) => {
+			if (!specifier.startsWith(".")) return;
+			if (!specifier.includes("packages/")) return;
+			const target = resolve(dirname(file), specifier);
+			const key = `${file} -> ${specifier}`;
+			runtimeImports.set(key, { file, specifier, target });
+			if (!existsSync(target)) {
+				problems.push({
+					kind: "missing-import",
+					detail: `${relative(ROOT, file)} imports ${specifier} but ${
+						relative(ROOT, target)
+					} does not exist`,
+				});
+			}
+		};
+
+		for (const match of content.matchAll(STATIC_IMPORT)) {
+			if (match[1]) continue; // type-only import: erased at runtime
+			consider(match[2]);
+		}
+		for (const match of content.matchAll(DYNAMIC_IMPORT)) consider(match[1]);
+		for (const match of content.matchAll(SIDE_EFFECT_IMPORT)) consider(match[1]);
+	}
+}
+
+/** Collect every file path a package manifest promises to publish. */
+function manifestEntries(manifest: {
+	main?: string;
+	exports?: unknown;
+	bin?: unknown;
+}): string[] {
+	const entries: string[] = [];
+	if (typeof manifest.main === "string") entries.push(manifest.main);
+	if (typeof manifest.bin === "string") entries.push(manifest.bin);
+	else if (manifest.bin && typeof manifest.bin === "object") {
+		for (const value of Object.values(manifest.bin as Record<string, string>)) {
+			if (typeof value === "string") entries.push(value);
+		}
+	}
+
+	const walk = (node: unknown): void => {
+		if (typeof node === "string") {
+			if (node.startsWith("./")) entries.push(node);
+			return;
+		}
+		if (node && typeof node === "object") {
+			for (const value of Object.values(node as Record<string, unknown>)) walk(value);
+		}
+	};
+	walk(manifest.exports);
+
+	return [...new Set(entries)];
+}
+
+/** Is the file tracked by git? A clean checkout only has tracked files. */
+function isTracked(file: string): boolean {
+	const run = spawnSync("git", ["ls-files", "--error-unmatch", "--", file], {
+		cwd: ROOT,
+		encoding: "utf8",
+	});
+	return run.status === 0;
+}
+
+/**
+ * Every workspace package must have its published entry points built.
+ *
+ * An entry that points into `src/` is a defect: the build emits into
+ * `dist/`, so a `src/*.js` entry only exists when somebody compiled the
+ * package in place and would be missing from a clean checkout.
+ */
+function checkPackageEntries(): void {
+	const packagesDir = join(ROOT, "packages");
+	if (!existsSync(packagesDir)) return;
+
+	for (const entry of readdirSync(packagesDir)) {
+		const dir = join(packagesDir, entry);
+		if (!statSync(dir).isDirectory()) continue;
+		const manifestPath = join(dir, "package.json");
+		if (!existsSync(manifestPath)) continue;
+
+		let manifest: { main?: string; exports?: unknown; bin?: unknown };
+		try {
+			manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+		} catch {
+			continue;
+		}
+
+		for (const target of manifestEntries(manifest)) {
+			const full = join(dir, target);
+			if (!existsSync(full)) {
+				problems.push({
+					kind: "missing-package",
+					detail: `packages/${entry} publishes ${target} but the file is not built`,
+				});
+				continue;
+			}
+			if (target.startsWith("./src/") && target.endsWith(".js")) {
+				// A package without any TypeScript source is vendored as
+				// compiled JavaScript (the telegram app). Its entry point
+				// stays in src/ - but the file must be tracked, otherwise a
+				// clean checkout publishes a package without its entry point.
+				const hasTypeScript = listFiles(join(dir, "src"), (file) =>
+					file.endsWith(".ts") && !file.endsWith(".d.ts"),
+				).length > 0;
+				const tracked = isTracked(join(dir, target));
+				if (hasTypeScript) {
+					problems.push({
+						kind: "missing-package",
+						detail: `packages/${entry} publishes ${target} from src/ - point it at the built dist/ file`,
+					});
+				} else if (!tracked) {
+					problems.push({
+						kind: "missing-package",
+						detail: `packages/${entry} publishes ${target} from src/ but the file is not tracked by git`,
+					});
+				}
+			}
+		}
+	}
+}
+
+/**
+ * A built output that is older than its source is stale.
+ *
+ * The release publishes the compiled `dist/`, so a dist that is older than the
+ * source it was compiled from ships yesterday's code. The build clears the
+ * incremental state before it compiles, so a fresh build is never stale.
+ */
+function checkStaleOutputs(): void {
+	const packagesDir = join(ROOT, "packages");
+	if (!existsSync(packagesDir)) return;
+
+	for (const entry of readdirSync(packagesDir)) {
+		const dir = join(packagesDir, entry);
+		if (!statSync(dir).isDirectory()) continue;
+		if (!existsSync(join(dir, "tsconfig.json"))) continue;
+		if (!existsSync(join(dir, "dist"))) continue;
+
+		const sources = listFiles(dir, (file) => {
+			if (!file.endsWith(".ts") || file.endsWith(".d.ts")) return false;
+			const rel = relative(dir, file).split("\\").join("/");
+			if (rel.startsWith("dist/") || rel.startsWith("node_modules/")) return false;
+			// Test sources are not part of the published build.
+			return !/^(test|tests|__tests__)\//.test(rel);
+		});
+		const outputs = listFiles(join(dir, "dist"), (file) => file.endsWith(".js"));
+		if (sources.length === 0 || outputs.length === 0) continue;
+
+		const newestSource = Math.max(...sources.map((file) => statSync(file).mtimeMs));
+		const oldestOutput = Math.min(...outputs.map((file) => statSync(file).mtimeMs));
+		if (newestSource > oldestOutput + 1_000) {
+			const newest = sources
+				.map((file) => ({ file, mtime: statSync(file).mtimeMs }))
+				.sort((a, b) => b.mtime - a.mtime)[0];
+			problems.push({
+				kind: "missing-dist",
+				detail: `packages/${entry} has a stale build - ${relative(
+					ROOT,
+					newest.file,
+				)} is newer than the compiled output. Run "bun run build".`,
+			});
+		}
+	}
+}
+
+/** The tarball npm would publish must contain the built output. */
+async function inspectTarball(): Promise<void> {
+	const stdout = await new Promise<string>((resolveText, rejectText) => {
+		execFile(
+			"npm",
+			["pack", "--dry-run", "--json", "--ignore-scripts"],
+			{ cwd: ROOT, maxBuffer: 64 * 1024 * 1024 },
+			(error, out, err) => {
+				if (error) {
+					rejectText(new Error(`${error.message}: ${String(err).slice(0, 400)}`));
+					return;
+				}
+				resolveText(out);
+			},
+		);
+	});
+
+	let files: string[] = [];
+	try {
+		// `npm pack --json` returns an array with one entry per packed tarball.
+		const parsed = JSON.parse(stdout) as
+			| { files?: { path: string }[] }[]
+			| { files?: { path: string }[] };
+		const entries = Array.isArray(parsed) ? parsed : [parsed];
+		files = entries.flatMap((entry) => entry?.files ?? []).map((file) => file.path);
+		if (files.length === 0) {
+			problems.push({
+				kind: "missing-tarball",
+				detail: "npm pack --dry-run did not return a file list",
+			});
+			return;
+		}
+	} catch {
+		problems.push({
+			kind: "missing-tarball",
+			detail: "npm pack --dry-run did not return a file list",
+		});
+		return;
+	}
+
+	const inTarball = new Set(files);
+	for (const { file, specifier, target } of runtimeImports.values()) {
+		const relativeTarget = relative(ROOT, target).split("\\").join("/");
+		if (!inTarball.has(relativeTarget)) {
+			problems.push({
+				kind: "missing-tarball",
+				detail: `${relativeTarget} (imported by ${relative(
+					ROOT,
+					file,
+				)} as ${specifier}) is not in the tarball`,
+			});
+		}
+	}
+}
+
+checkImports();
+checkPackageEntries();
+checkStaleOutputs();
+if (verifyTarball) await inspectTarball();
+
+if (problems.length > 0) {
+	console.error(`[verify-package-contents] FAILED with ${problems.length} problem(s):`);
+	for (const problem of problems) {
+		console.error(`  - [${problem.kind}] ${problem.detail}`);
+	}
+	console.error(
+		"",
+		"Every internal package must ship inside pi-harness-runtime. Run `bun run build` and check the tsc output before publishing.",
+	);
+	process.exit(1);
+}
+
+console.log(
+	`[verify-package-contents] OK - ${runtimeImports.size} runtime import(s) resolved${
+		verifyTarball ? ", tarball verified" : ""
+	}`,
+);

package/scripts/ws-server.ts

@@ -12,7 +12,7 @@
  *   Telegram/LINE → Webhook → This Server → WebSocket → Local Client
  */
 
-import { createRelayServer, type RelayServerOptions } from "../packages/relay/src/server";
+import { createRelayServer, type RelayServerOptions } from "../packages/relay/dist/server.js";
 
 // Configuration from environment
 const PORT = parseInt(process.env.WS_PORT || "8444", 10);

package/tracker.ts

@@ -15,7 +15,7 @@ import {
 	ensureUsageDir,
 	getUsageLogPath,
 	readJsonl,
-} from "./cli.ts";
+} from "./cli.js";
 import { unlinkSync } from "node:fs";
 
 export interface UsageRecord {

package/harness/browser-scrapers/base-browser-scraper.d.ts

@@ -1,91 +0,0 @@
-/**
- * Base Browser Scraper — Abstract class for browser-based quota scraping
- *
- * Uses Playwright with Chrome profiles to scrape JavaScript-rendered pages
- * that require authentication. Similar approach to google-flow-mcp.
- */
-import type { Page, Browser, BrowserContext } from "playwright";
-export interface BrowserScraperConfig {
-    /** Headless mode (default: true) */
-    headless?: boolean;
-    /** Page load timeout in ms (default: 30000) */
-    timeout?: number;
-    /** Viewport dimensions */
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    /** Slow down operations by ms (for debugging) */
-    slowMo?: number;
-    /** Provider name for logging */
-    provider: string;
-    /** URL to scrape */
-    url: string;
-}
-export interface QuotaScrapingResult<T> {
-    /** Whether scraping was successful */
-    success: boolean;
-    /** The scraped data */
-    data?: T;
-    /** Error message if failed */
-    error?: string;
-    /** Timestamp of scrape */
-    scrapedAt: string;
-    /** Screenshot path if debug screenshot was taken */
-    screenshotPath?: string;
-}
-/**
- * Abstract base class for browser-based quota scrapers
- */
-export declare abstract class BaseBrowserScraper<T> {
-    protected config: Required<BrowserScraperConfig>;
-    protected browser: Browser | null;
-    protected context: BrowserContext | null;
-    protected page: Page | null;
-    protected screenshotsEnabled: boolean;
-    protected screenshotsDir: string;
-    constructor(config: BrowserScraperConfig);
-    /**
-     * Initialize Playwright and launch browser
-     */
-    protected abstract createBrowser(): Promise<void>;
-    /**
-     * Take a debug screenshot
-     */
-    takeScreenshot(name: string): Promise<string | undefined>;
-    /**
-     * Wait for a selector with retry logic
-     */
-    protected waitForSelector(selector: string, options?: {
-        timeout?: number;
-        state?: "attached" | "detached" | "visible" | "hidden";
-    }): Promise<boolean>;
-    /**
-     * Extract text content from page
-     */
-    protected extractText(selector: string): Promise<string | null>;
-    /**
-     * Extract number from text (handles various formats like "1.5 GB", "$10.00", etc.)
-     */
-    protected extractNumber(text: string | null, pattern?: RegExp): number | null;
-    /**
-     * Main scraping method — navigates and extracts data
-     */
-    scrape(): Promise<QuotaScrapingResult<T>>;
-    /**
-     * Check if current page is a login page
-     */
-    protected abstract isLoginPage(): Promise<boolean>;
-    /**
-     * Extract quota data from the page
-     */
-    protected abstract extractData(): Promise<T | null>;
-    /**
-     * Cleanup browser resources
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Enable screenshot capture for debugging
-     */
-    enableScreenshots(dir?: string): void;
-}

package/harness/browser-scrapers/chrome-profile-manager.d.ts

@@ -1,80 +0,0 @@
-/**
- * Chrome Profile Manager — Browser-based quota scraping via Playwright
- *
- * Key concepts from google-flow-mcp:
- * - Uses Playwright to connect to existing Chrome profile with stored cookies
- * - Maintains persistent session across runs
- * - Bypasses anti-bot measures by launching Chrome directly
- *
- * This enables scraping JavaScript-rendered pages that require authentication:
- * - chatgpt.com/codex/cloud/settings/analytics
- * - z.ai/manage-apikey/coding-plan/personal/usage
- * - etc.
- */
-export interface ChromeProfileConfig {
-    /** Provider name (e.g., "codex", "z-ai") */
-    provider: string;
-    /** Path to Chrome user data directory (auto-detected if not provided) */
-    userDataDir?: string;
-    /** Profile directory name within userDataDir */
-    profileName?: string;
-    /** Path to browser binary (auto-detected if not provided) */
-    binaryPath?: string;
-    /** Arguments to pass to Chrome */
-    extraArgs?: string[];
-    /** Headless mode (default: true for scraping) */
-    headless?: boolean;
-    /** Launch timeout in ms */
-    launchTimeout?: number;
-}
-export interface BrowserProfile {
-    /** Path to the profile directory */
-    profilePath: string;
-    /** Provider name */
-    provider: string;
-    /** Whether the profile exists */
-    exists: boolean;
-    /** Last used timestamp */
-    lastUsed?: number;
-}
-/** Auto-detect Chrome user data directory based on OS */
-export declare function detectChromeUserDataDir(): string | null;
-/** Auto-detect Chrome binary path */
-export declare function detectChromeBinary(): string | null;
-/**
- * Chrome Profile Manager for browser-based scraping
- *
- * Manages Chrome profiles for different providers to maintain
- * authenticated sessions across scraping runs.
- */
-export declare class ChromeProfileManager {
-    private profilesDir;
-    private profiles;
-    constructor(profilesDir?: string);
-    private ensureProfilesDir;
-    private getProfileMetaPath;
-    private loadProfiles;
-    /**
-     * Get profile path for a provider
-     */
-    getProfilePath(provider: string): string;
-    /**
-     * Ensure profile directory exists
-     */
-    ensureProfile(provider: string): BrowserProfile;
-    private saveProfileMeta;
-    /**
-     * List all managed profiles
-     */
-    listProfiles(): BrowserProfile[];
-    /**
-     * Delete a profile
-     */
-    deleteProfile(provider: string): Promise<void>;
-    /**
-     * Get Chrome launch arguments for anti-bot evasion
-     * Based on google-flow-mcp approach
-     */
-    getLaunchArgs(config: ChromeProfileConfig): string[];
-}
-export declare function getChromeProfileManager(): ChromeProfileManager;

package/harness/browser-scrapers/codex-browser-scraper.d.ts

@@ -1,60 +0,0 @@
-/**
- * Codex Browser Scraper — Scrapes chatgpt.com/codex/cloud/settings/analytics
- *
- * Uses Playwright with Chrome profile to access the authenticated page
- * and extract usage/quota data.
- */
-import { BaseBrowserScraper } from "./base-browser-scraper.js";
-export interface CodexQuotaData {
-    provider: "openai-codex";
-    /** Plan type (e.g., "pro", "plus") */
-    planType?: string;
-    /** Current usage percentage (0-100) */
-    usagePercent: number;
-    /** Total quota amount */
-    totalQuota?: string;
-    /** Used quota amount */
-    usedQuota?: string;
-    /** Remaining quota */
-    remainingQuota?: string;
-    /** Reset date/time */
-    resetAt?: string;
-    /** Usage period description */
-    period?: string;
-    /** Raw data for debugging */
-    rawData?: Record<string, unknown>;
-    /** Timestamp */
-    scrapedAt: string;
-}
-interface CodexScraperConfig {
-    provider?: string;
-    url?: string;
-    headless?: boolean;
-    timeout?: number;
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    slowMo?: number;
-}
-/**
- * Codex Browser Scraper
- *
- * Scrapes usage data from chatgpt.com/codex/cloud/settings/analytics
- */
-export declare class CodexBrowserScraper extends BaseBrowserScraper<CodexQuotaData> {
-    constructor(config?: Partial<CodexScraperConfig>);
-    protected createBrowser(): Promise<void>;
-    private getProfileDir;
-    protected isLoginPage(): Promise<boolean>;
-    protected extractData(): Promise<CodexQuotaData | null>;
-    private extractUsageData;
-    private extractAdditionalData;
-    private extractFromHeadings;
-    private extractChartData;
-}
-/**
- * Quick scrape function
- */
-export declare function scrapeCodexQuota(): Promise<CodexQuotaData | null>;
-export {};