antigravity-auth 1.6.0

package/dist/opencode/hooks/auto-update-checker/index.js

@@ -0,0 +1,121 @@
+import { getCachedVersion, getLocalDevVersion, findPluginEntry, getLatestVersion, updatePinnedVersion } from "./checker";
+import { invalidatePackage } from "./cache";
+import { PACKAGE_NAME } from "./constants";
+import { logAutoUpdate } from "./logging";
+export function createAutoUpdateCheckerHook(client, directory, options = {}) {
+    const { showStartupToast = true, autoUpdate = true } = options;
+    let hasChecked = false;
+    return {
+        event: ({ event }) => {
+            if (event.type !== "session.created")
+                return;
+            if (hasChecked)
+                return;
+            const props = event.properties;
+            if (props?.info?.parentID)
+                return;
+            hasChecked = true;
+            setTimeout(() => {
+                const localDevVersion = getLocalDevVersion(directory);
+                if (localDevVersion) {
+                    if (showStartupToast) {
+                        showLocalDevToast(client, localDevVersion).catch(() => { });
+                    }
+                    logAutoUpdate("Local development mode");
+                    return;
+                }
+                runBackgroundUpdateCheck(client, directory, autoUpdate).catch((err) => {
+                    logAutoUpdate(`Background update check failed: ${err}`);
+                });
+            }, 0);
+        },
+    };
+}
+async function runBackgroundUpdateCheck(client, directory, autoUpdate) {
+    const pluginInfo = findPluginEntry(directory);
+    if (!pluginInfo) {
+        logAutoUpdate("Plugin not found in config");
+        return;
+    }
+    const cachedVersion = getCachedVersion();
+    const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+    if (!currentVersion) {
+        logAutoUpdate("No version found (cached or pinned)");
+        return;
+    }
+    if (currentVersion.includes('-')) {
+        logAutoUpdate(`Prerelease version (${currentVersion}), skipping auto-update`);
+        return;
+    }
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+        logAutoUpdate("Failed to fetch latest version");
+        return;
+    }
+    if (currentVersion === latestVersion) {
+        logAutoUpdate("Already on latest version");
+        return;
+    }
+    logAutoUpdate(`Update available: ${currentVersion} → ${latestVersion}`);
+    if (!autoUpdate) {
+        await showUpdateAvailableToast(client, latestVersion);
+        logAutoUpdate("Auto-update disabled, notification only");
+        return;
+    }
+    if (pluginInfo.isPinned) {
+        const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion);
+        if (updated) {
+            invalidatePackage(PACKAGE_NAME);
+            await showAutoUpdatedToast(client, currentVersion, latestVersion);
+            logAutoUpdate(`Config updated: ${pluginInfo.entry} → ${PACKAGE_NAME}@${latestVersion}`);
+        }
+        else {
+            await showUpdateAvailableToast(client, latestVersion);
+        }
+    }
+    else {
+        invalidatePackage(PACKAGE_NAME);
+        await showUpdateAvailableToast(client, latestVersion);
+    }
+}
+async function showUpdateAvailableToast(client, latestVersion) {
+    await client.tui
+        .showToast({
+        body: {
+            title: `Antigravity Auth Update`,
+            message: `v${latestVersion} available. Restart OpenCode to apply.`,
+            variant: "info",
+            duration: 8000,
+        },
+    })
+        .catch(() => { });
+    logAutoUpdate(`Update available toast shown: v${latestVersion}`);
+}
+async function showAutoUpdatedToast(client, oldVersion, newVersion) {
+    await client.tui
+        .showToast({
+        body: {
+            title: `Antigravity Auth Updated!`,
+            message: `v${oldVersion} → v${newVersion}\nRestart OpenCode to apply.`,
+            variant: "success",
+            duration: 8000,
+        },
+    })
+        .catch(() => { });
+    logAutoUpdate(`Auto-updated toast shown: v${oldVersion} → v${newVersion}`);
+}
+async function showLocalDevToast(client, version) {
+    await client.tui
+        .showToast({
+        body: {
+            title: `Antigravity Auth ${version} (dev)`,
+            message: "Running in local development mode.",
+            variant: "warning",
+            duration: 5000,
+        },
+    })
+        .catch(() => { });
+    logAutoUpdate(`Local dev toast shown: v${version}`);
+}
+export { checkForUpdate, getCachedVersion, getLatestVersion } from "./checker";
+export { invalidatePackage, invalidateCache } from "./cache";

package/dist/opencode/hooks/auto-update-checker/logging.d.ts

@@ -0,0 +1,2 @@
+export declare function formatAutoUpdateLogMessage(message: string): string;
+export declare function logAutoUpdate(message: string): void;

package/dist/opencode/hooks/auto-update-checker/logging.js

@@ -0,0 +1,8 @@
+import { debugLogToFile } from "../../../src/plugin/debug";
+const AUTO_UPDATE_LOG_PREFIX = "[auto-update-checker]";
+export function formatAutoUpdateLogMessage(message) {
+    return `${AUTO_UPDATE_LOG_PREFIX} ${message}`;
+}
+export function logAutoUpdate(message) {
+    debugLogToFile(formatAutoUpdateLogMessage(message));
+}

package/dist/opencode/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,24 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: string[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface UpdateCheckResult {
+    needsUpdate: boolean;
+    currentVersion: string | null;
+    latestVersion: string | null;
+    isLocalDev: boolean;
+    isPinned: boolean;
+}
+export interface AutoUpdateCheckerOptions {
+    showStartupToast?: boolean;
+    autoUpdate?: boolean;
+}

package/dist/opencode/hooks/auto-update-checker/types.js

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

package/dist/opencode/plugin.d.ts

@@ -0,0 +1,29 @@
+import { type HeaderStyle } from "../src/constants";
+import { type ModelFamily } from "../src/plugin/accounts";
+import { type AntigravityConfig } from "../src/plugin/config";
+import type { PluginContext, PluginResult } from "../src/plugin/types";
+/**
+ * Creates an Antigravity OAuth plugin for a specific provider ID.
+ */
+export declare const createAntigravityPlugin: (providerId: string) => ({ client, directory }: PluginContext) => Promise<PluginResult>;
+export declare const AntigravityCLIOAuthPlugin: ({ client, directory }: PluginContext) => Promise<PluginResult>;
+export declare const GoogleOAuthPlugin: ({ client, directory }: PluginContext) => Promise<PluginResult>;
+declare function resolveQuotaFallbackHeaderStyle(input: {
+    family: ModelFamily;
+    headerStyle: HeaderStyle;
+    alternateStyle: HeaderStyle | null;
+}): HeaderStyle | null;
+type HeaderRoutingDecision = {
+    cliFirst: boolean;
+    preferredHeaderStyle: HeaderStyle;
+    explicitQuota: boolean;
+    allowQuotaFallback: boolean;
+};
+declare function resolveHeaderRoutingDecision(urlString: string, family: ModelFamily, config: AntigravityConfig): HeaderRoutingDecision;
+declare function getHeaderStyleFromUrl(urlString: string, family: ModelFamily, cliFirst?: boolean): HeaderStyle;
+export declare const __testExports: {
+    getHeaderStyleFromUrl: typeof getHeaderStyleFromUrl;
+    resolveHeaderRoutingDecision: typeof resolveHeaderRoutingDecision;
+    resolveQuotaFallbackHeaderStyle: typeof resolveQuotaFallbackHeaderStyle;
+};
+export {};