antigravity-auth 1.6.0

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const PACKAGE_NAME = "opencode-antigravity-auth";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-antigravity-auth/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+export declare const CACHE_DIR: string;
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/hooks/auto-update-checker/constants.js

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+import * as os from "node:os";
+export const PACKAGE_NAME = "opencode-antigravity-auth";
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+export const NPM_FETCH_TIMEOUT = 5000;
+function getCacheDir() {
+    if (process.platform === "win32") {
+        return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
+    }
+    return path.join(os.homedir(), ".cache", "opencode");
+}
+export const CACHE_DIR = getCacheDir();
+export const INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+function getUserConfigDir() {
+    if (process.platform === "win32") {
+        return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    }
+    return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+}
+export const USER_CONFIG_DIR = getUserConfigDir();
+export const USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+export const USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,33 @@
+import type { AutoUpdateCheckerOptions } from "./types";
+interface PluginClient {
+    tui: {
+        showToast(options: {
+            body: {
+                title?: string;
+                message: string;
+                variant: "info" | "warning" | "success" | "error";
+                duration?: number;
+            };
+        }): Promise<unknown>;
+    };
+}
+interface SessionCreatedEvent {
+    type: "session.created";
+    properties?: {
+        info?: {
+            parentID?: string;
+        };
+    };
+}
+type PluginEvent = SessionCreatedEvent | {
+    type: string;
+    properties?: unknown;
+};
+export declare function createAutoUpdateCheckerHook(client: PluginClient, directory: string, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: PluginEvent;
+    }) => void;
+};
+export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types";
+export { checkForUpdate, getCachedVersion, getLatestVersion } from "./checker";
+export { invalidatePackage, invalidateCache } from "./cache";

package/dist/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/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/hooks/auto-update-checker/logging.js

@@ -0,0 +1,8 @@
+import { debugLogToFile } from "../../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/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/hooks/auto-update-checker/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin } from "./plugin";
+export { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin };
+export { authorizeAntigravity, exchangeAntigravity, } from "./antigravity/oauth";
+export type { AntigravityAuthorization, AntigravityTokenExchangeResult, } from "./antigravity/oauth";
+export default AntigravityCLIOAuthPlugin;
+export declare const server: any;

package/dist/index.js

@@ -0,0 +1,5 @@
+import { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin } from "./plugin";
+export { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin };
+export { authorizeAntigravity, exchangeAntigravity, } from "./antigravity/oauth";
+export default AntigravityCLIOAuthPlugin;
+export const server = AntigravityCLIOAuthPlugin;

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

@@ -0,0 +1,2 @@
+export declare function invalidatePackage(packageName?: string): boolean;
+export declare function invalidateCache(): boolean;

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

@@ -0,0 +1,70 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CACHE_DIR, PACKAGE_NAME } from "./constants";
+function stripTrailingCommas(json) {
+    return json.replace(/,(\s*[}\]])/g, "$1");
+}
+function removeFromBunLock(packageName) {
+    const lockPath = path.join(CACHE_DIR, "bun.lock");
+    if (!fs.existsSync(lockPath))
+        return false;
+    try {
+        const content = fs.readFileSync(lockPath, "utf-8");
+        const lock = JSON.parse(stripTrailingCommas(content));
+        let modified = false;
+        if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
+            delete lock.workspaces[""].dependencies[packageName];
+            modified = true;
+        }
+        if (lock.packages?.[packageName]) {
+            delete lock.packages[packageName];
+            modified = true;
+        }
+        if (modified) {
+            fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+            console.log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+        }
+        return modified;
+    }
+    catch {
+        return false;
+    }
+}
+export function invalidatePackage(packageName = PACKAGE_NAME) {
+    try {
+        const pkgDir = path.join(CACHE_DIR, "node_modules", packageName);
+        const pkgJsonPath = path.join(CACHE_DIR, "package.json");
+        let packageRemoved = false;
+        let dependencyRemoved = false;
+        let lockRemoved = false;
+        if (fs.existsSync(pkgDir)) {
+            fs.rmSync(pkgDir, { recursive: true, force: true });
+            console.log(`[auto-update-checker] Package removed: ${pkgDir}`);
+            packageRemoved = true;
+        }
+        if (fs.existsSync(pkgJsonPath)) {
+            const content = fs.readFileSync(pkgJsonPath, "utf-8");
+            const pkgJson = JSON.parse(content);
+            if (pkgJson.dependencies?.[packageName]) {
+                delete pkgJson.dependencies[packageName];
+                fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+                console.log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
+                dependencyRemoved = true;
+            }
+        }
+        lockRemoved = removeFromBunLock(packageName);
+        if (!packageRemoved && !dependencyRemoved && !lockRemoved) {
+            console.log(`[auto-update-checker] Package not found, nothing to invalidate: ${packageName}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        console.error("[auto-update-checker] Failed to invalidate package:", err);
+        return false;
+    }
+}
+export function invalidateCache() {
+    console.warn("[auto-update-checker] WARNING: invalidateCache is deprecated, use invalidatePackage");
+    return invalidatePackage();
+}

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

@@ -0,0 +1,15 @@
+import type { UpdateCheckResult } from "./types";
+export declare function isLocalDevMode(directory: string): boolean;
+export declare function getLocalDevPath(directory: string): string | null;
+export declare function getLocalDevVersion(directory: string): string | null;
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+export declare function getCachedVersion(): string | null;
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+export declare function getLatestVersion(): Promise<string | null>;
+export declare function checkForUpdate(directory: string): Promise<UpdateCheckResult>;

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

@@ -0,0 +1,233 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PACKAGE_NAME, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT, INSTALLED_PACKAGE_JSON, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC, } from "./constants";
+import { logAutoUpdate } from "./logging";
+export function isLocalDevMode(directory) {
+    return getLocalDevPath(directory) !== null;
+}
+function stripJsonComments(json) {
+    return json
+        .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => (g ? "" : m))
+        .replace(/,(\s*[}\]])/g, "$1");
+}
+function getConfigPaths(directory) {
+    return [
+        path.join(directory, ".opencode", "opencode.json"),
+        path.join(directory, ".opencode", "opencode.jsonc"),
+        path.join(directory, ".opencode.json"),
+        USER_OPENCODE_CONFIG,
+        USER_OPENCODE_CONFIG_JSONC,
+    ];
+}
+export function getLocalDevPath(directory) {
+    for (const configPath of getConfigPaths(directory)) {
+        try {
+            if (!fs.existsSync(configPath))
+                continue;
+            const content = fs.readFileSync(configPath, "utf-8");
+            const config = JSON.parse(stripJsonComments(content));
+            const plugins = config.plugin ?? [];
+            for (const entry of plugins) {
+                if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
+                    try {
+                        return fileURLToPath(entry);
+                    }
+                    catch {
+                        return entry.replace("file://", "");
+                    }
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function findPackageJsonUp(startPath) {
+    try {
+        const stat = fs.statSync(startPath);
+        let dir = stat.isDirectory() ? startPath : path.dirname(startPath);
+        for (let i = 0; i < 10; i++) {
+            const pkgPath = path.join(dir, "package.json");
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const content = fs.readFileSync(pkgPath, "utf-8");
+                    const pkg = JSON.parse(content);
+                    if (pkg.name === PACKAGE_NAME)
+                        return pkgPath;
+                }
+                catch {
+                    continue;
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function getLocalDevVersion(directory) {
+    const localPath = getLocalDevPath(directory);
+    if (!localPath)
+        return null;
+    try {
+        const pkgPath = findPackageJsonUp(localPath);
+        if (!pkgPath)
+            return null;
+        const content = fs.readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(content);
+        return pkg.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function findPluginEntry(directory) {
+    for (const configPath of getConfigPaths(directory)) {
+        try {
+            if (!fs.existsSync(configPath))
+                continue;
+            const content = fs.readFileSync(configPath, "utf-8");
+            const config = JSON.parse(stripJsonComments(content));
+            const plugins = config.plugin ?? [];
+            for (const entry of plugins) {
+                if (entry === PACKAGE_NAME) {
+                    return { entry, isPinned: false, pinnedVersion: null, configPath };
+                }
+                if (entry.startsWith(`${PACKAGE_NAME}@`)) {
+                    const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
+                    const isPinned = pinnedVersion !== "latest";
+                    return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null, configPath };
+                }
+                if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
+                    return { entry, isPinned: false, pinnedVersion: null, configPath };
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function getCachedVersion() {
+    try {
+        if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
+            const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.version)
+                return pkg.version;
+        }
+    }
+    catch {
+        return null;
+    }
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = findPackageJsonUp(currentDir);
+        if (pkgPath) {
+            const content = fs.readFileSync(pkgPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.version)
+                return pkg.version;
+        }
+    }
+    catch (err) {
+        logAutoUpdate(`Failed to resolve version from current directory: ${err}`);
+    }
+    return null;
+}
+export function updatePinnedVersion(configPath, oldEntry, newVersion) {
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const newEntry = `${PACKAGE_NAME}@${newVersion}`;
+        const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
+        if (!pluginMatch || pluginMatch.index === undefined) {
+            logAutoUpdate(`No "plugin" array found in ${configPath}`);
+            return false;
+        }
+        const startIdx = pluginMatch.index + pluginMatch[0].length;
+        let bracketCount = 1;
+        let endIdx = startIdx;
+        for (let i = startIdx; i < content.length && bracketCount > 0; i++) {
+            if (content[i] === "[")
+                bracketCount++;
+            else if (content[i] === "]")
+                bracketCount--;
+            endIdx = i;
+        }
+        const before = content.slice(0, startIdx);
+        const pluginArrayContent = content.slice(startIdx, endIdx);
+        const after = content.slice(endIdx);
+        const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`["']${escapedOldEntry}["']`);
+        if (!regex.test(pluginArrayContent)) {
+            logAutoUpdate(`Entry "${oldEntry}" not found in plugin array of ${configPath}`);
+            return false;
+        }
+        const updatedPluginArray = pluginArrayContent.replace(regex, `"${newEntry}"`);
+        const updatedContent = before + updatedPluginArray + after;
+        if (updatedContent === content) {
+            logAutoUpdate(`No changes made to ${configPath}`);
+            return false;
+        }
+        fs.writeFileSync(configPath, updatedContent, "utf-8");
+        logAutoUpdate(`Updated ${configPath}: ${oldEntry} → ${newEntry}`);
+        return true;
+    }
+    catch (err) {
+        console.error(`[auto-update-checker] Failed to update config file ${configPath}:`, err);
+        return false;
+    }
+}
+export async function getLatestVersion() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+    try {
+        const response = await fetch(NPM_REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export async function checkForUpdate(directory) {
+    if (isLocalDevMode(directory)) {
+        logAutoUpdate("Local dev mode detected, skipping update check");
+        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: true, isPinned: false };
+    }
+    const pluginInfo = findPluginEntry(directory);
+    if (!pluginInfo) {
+        logAutoUpdate("Plugin not found in config");
+        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: false, isPinned: false };
+    }
+    const currentVersion = getCachedVersion() ?? pluginInfo.pinnedVersion;
+    if (!currentVersion) {
+        logAutoUpdate("No version found (cached or pinned)");
+        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: false, isPinned: pluginInfo.isPinned };
+    }
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+        logAutoUpdate("Failed to fetch latest version");
+        return { needsUpdate: false, currentVersion, latestVersion: null, isLocalDev: false, isPinned: pluginInfo.isPinned };
+    }
+    const needsUpdate = currentVersion !== latestVersion;
+    logAutoUpdate(`Current: ${currentVersion}, Latest: ${latestVersion}, NeedsUpdate: ${needsUpdate}`);
+    return { needsUpdate, currentVersion, latestVersion, isLocalDev: false, isPinned: pluginInfo.isPinned };
+}

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

@@ -0,0 +1,8 @@
+export declare const PACKAGE_NAME = "opencode-antigravity-auth";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-antigravity-auth/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+export declare const CACHE_DIR: string;
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

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

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+import * as os from "node:os";
+export const PACKAGE_NAME = "opencode-antigravity-auth";
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+export const NPM_FETCH_TIMEOUT = 5000;
+function getCacheDir() {
+    if (process.platform === "win32") {
+        return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
+    }
+    return path.join(os.homedir(), ".cache", "opencode");
+}
+export const CACHE_DIR = getCacheDir();
+export const INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+function getUserConfigDir() {
+    if (process.platform === "win32") {
+        return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    }
+    return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+}
+export const USER_CONFIG_DIR = getUserConfigDir();
+export const USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+export const USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");

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

@@ -0,0 +1,33 @@
+import type { AutoUpdateCheckerOptions } from "./types";
+interface PluginClient {
+    tui: {
+        showToast(options: {
+            body: {
+                title?: string;
+                message: string;
+                variant: "info" | "warning" | "success" | "error";
+                duration?: number;
+            };
+        }): Promise<unknown>;
+    };
+}
+interface SessionCreatedEvent {
+    type: "session.created";
+    properties?: {
+        info?: {
+            parentID?: string;
+        };
+    };
+}
+type PluginEvent = SessionCreatedEvent | {
+    type: string;
+    properties?: unknown;
+};
+export declare function createAutoUpdateCheckerHook(client: PluginClient, directory: string, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: PluginEvent;
+    }) => void;
+};
+export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types";
+export { checkForUpdate, getCachedVersion, getLatestVersion } from "./checker";
+export { invalidatePackage, invalidateCache } from "./cache";