Add robust companion resolution and runtime cache

Refactor companion resolution to handle multiple import specifiers and runtime cache locations. Adds robust fallthrough resolution: try published JS constants, probe OpenCode runtime cache candidate paths, read source TS/JS constants, inspect package.json-root candidates, and finally package entry. Handles package export-blocking errors, missing files, and non-fallthrough resolver errors; normalizes credentials and parses credential values from source files. Includes many helper functions to build presence/credential states and to try reading candidate files. Tests updated to mock runtime dirs, cover cache probing, package export blocks, package-root lookup, direct runtime candidates, and error scenarios.

Author: slkiser

src/lib/google-antigravity-companion.ts

@@ -1,10 +1,25 @@
+import { readFile } from "fs/promises";
 import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
+import { getOpencodeRuntimeDirCandidates } from "./opencode-runtime-paths.js";
+
 const require = createRequire(import.meta.url);
 
 const COMPANION_PACKAGE_NAME = "opencode-antigravity-auth";
-const COMPANION_IMPORT_SPECIFIER = `${COMPANION_PACKAGE_NAME}/dist/src/constants.js`;
+const COMPANION_JS_IMPORT_SPECIFIERS = [
+  `${COMPANION_PACKAGE_NAME}/dist/src/constants.js`,
+  `${COMPANION_PACKAGE_NAME}/src/constants.js`,
+] as const;
+const COMPANION_SOURCE_IMPORT_SPECIFIER = `${COMPANION_PACKAGE_NAME}/src/constants.ts`;
+const COMPANION_PACKAGE_JSON_SPECIFIER = `${COMPANION_PACKAGE_NAME}/package.json`;
+const COMPANION_DIRECT_CANDIDATE_PATHS = [
+  ["dist", "src", "constants.js"],
+  ["src", "constants.ts"],
+  ["src", "constants.js"],
+  ["dist", "index.js"],
+] as const;
 const COMPANION_MISSING_ERROR = `Install ${COMPANION_PACKAGE_NAME} separately to enable Google Antigravity quota`;
 const COMPANION_INVALID_ERROR = `Installed ${COMPANION_PACKAGE_NAME} package is incompatible`;
 
@@ -51,6 +66,10 @@ type CompanionModule = {
   ANTIGRAVITY_CLIENT_SECRET?: unknown;
 };
 
+type CompanionResolutionContext = {
+  packageFound: boolean;
+};
+
 let resolvedCompanionStatePromise: Promise<ResolvedCompanionState> | null = null;
 
 function isModuleNotFoundError(error: unknown): boolean {
@@ -67,94 +86,288 @@ function isModuleNotFoundError(error: unknown): boolean {
   return message.includes("Cannot find module");
 }
 
-async function resolveCompanionState(): Promise<ResolvedCompanionState> {
-  let resolvedPath: string;
+function isPackagePathNotExportedError(error: unknown): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+
+  return "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+}
+
+function isFallthroughResolutionError(error: unknown): boolean {
+  return isModuleNotFoundError(error) || isPackagePathNotExportedError(error);
+}
+
+function normalizeCredential(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function getCompanionResolvePaths(): string[] {
+  return getOpencodeRuntimeDirCandidates().cacheDirs;
+}
 
+function markPackageFoundForExportBlock(
+  error: unknown,
+  context: CompanionResolutionContext,
+): void {
+  if (isPackagePathNotExportedError(error)) {
+    context.packageFound = true;
+  }
+}
+
+function resolveCompanionSpecifier(
+  specifier: string,
+  context: CompanionResolutionContext,
+): string {
   try {
-    resolvedPath = require.resolve(COMPANION_IMPORT_SPECIFIER);
+    return require.resolve(specifier);
   } catch (error) {
-    if (isModuleNotFoundError(error)) {
-      return {
-        presence: {
-          state: "missing",
-          importSpecifier: COMPANION_IMPORT_SPECIFIER,
-          error: COMPANION_MISSING_ERROR,
-        },
-        credentials: {
-          state: "missing",
-          error: COMPANION_MISSING_ERROR,
-        },
-      };
+    markPackageFoundForExportBlock(error, context);
+    if (!isFallthroughResolutionError(error)) {
+      throw error;
     }
 
-    return {
-      presence: {
-        state: "invalid",
-        importSpecifier: COMPANION_IMPORT_SPECIFIER,
-        error: COMPANION_INVALID_ERROR,
-      },
-      credentials: {
-        state: "invalid",
-        error: COMPANION_INVALID_ERROR,
-      },
-    };
+    try {
+      return require.resolve(specifier, { paths: getCompanionResolvePaths() });
+    } catch (resolvePathsError) {
+      markPackageFoundForExportBlock(resolvePathsError, context);
+      throw resolvePathsError;
+    }
+  }
+}
+
+function buildConfiguredState(params: {
+  importSpecifier: string;
+  resolvedPath: string;
+  clientId: string;
+  clientSecret: string;
+}): ResolvedCompanionState {
+  return {
+    presence: {
+      state: "present",
+      importSpecifier: params.importSpecifier,
+      resolvedPath: params.resolvedPath,
+    },
+    credentials: {
+      state: "configured",
+      clientId: params.clientId,
+      clientSecret: params.clientSecret,
+      resolvedPath: params.resolvedPath,
+    },
+  };
+}
+
+function buildInvalidState(importSpecifier: string, resolvedPath?: string): ResolvedCompanionState {
+  return {
+    presence: {
+      state: "invalid",
+      importSpecifier,
+      ...(resolvedPath ? { resolvedPath } : {}),
+      error: COMPANION_INVALID_ERROR,
+    },
+    credentials: {
+      state: "invalid",
+      ...(resolvedPath ? { resolvedPath } : {}),
+      error: COMPANION_INVALID_ERROR,
+    },
+  };
+}
+
+function parseSourceCredentials(content: string): { clientId: string; clientSecret: string } | null {
+  const clientId =
+    content.match(/(?:export\s+const|const|var)\s+ANTIGRAVITY_CLIENT_ID\s*=\s*["']([^"']+)["']/)?.[1]?.trim() ?? "";
+  const clientSecret =
+    content.match(/(?:export\s+const|const|var)\s+ANTIGRAVITY_CLIENT_SECRET\s*=\s*["']([^"']+)["']/)?.[1]?.trim() ?? "";
+
+  return clientId && clientSecret ? { clientId, clientSecret } : null;
+}
+
+function getPackageCredentialPaths(packageRoot: string): string[] {
+  return COMPANION_DIRECT_CANDIDATE_PATHS.map((parts) => join(packageRoot, ...parts));
+}
+
+function getRuntimeCredentialPaths(): string[] {
+  return getCompanionResolvePaths().flatMap((cacheDir) =>
+    getPackageCredentialPaths(join(cacheDir, "node_modules", COMPANION_PACKAGE_NAME)),
+  );
+}
+
+function isMissingFileError(error: unknown): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+
+  const code = "code" in error ? error.code : undefined;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+
+async function tryReadCredentialsPath(
+  importSpecifier: string,
+  resolvedPath: string,
+): Promise<ResolvedCompanionState | null> {
+  let content: string;
+  try {
+    content = await readFile(resolvedPath, "utf8");
+  } catch (error) {
+    return isMissingFileError(error) ? null : buildInvalidState(importSpecifier, resolvedPath);
+  }
+
+  const credentials = parseSourceCredentials(content);
+  if (!credentials) {
+    return buildInvalidState(importSpecifier, resolvedPath);
+  }
+
+  return buildConfiguredState({
+    importSpecifier,
+    resolvedPath,
+    clientId: credentials.clientId,
+    clientSecret: credentials.clientSecret,
+  });
+}
+
+async function tryResolveJsConstants(
+  importSpecifier: string,
+  context: CompanionResolutionContext,
+): Promise<ResolvedCompanionState | null> {
+  let resolvedPath: string;
+  try {
+    resolvedPath = resolveCompanionSpecifier(importSpecifier, context);
+  } catch (error) {
+    if (isFallthroughResolutionError(error)) {
+      return null;
+    }
+    return buildInvalidState(importSpecifier);
   }
 
   let companionModule: CompanionModule;
   try {
     companionModule = (await import(pathToFileURL(resolvedPath).href)) as CompanionModule;
   } catch {
-    return {
-      presence: {
-        state: "invalid",
-        importSpecifier: COMPANION_IMPORT_SPECIFIER,
-        resolvedPath,
-        error: COMPANION_INVALID_ERROR,
-      },
-      credentials: {
-        state: "invalid",
-        resolvedPath,
-        error: COMPANION_INVALID_ERROR,
-      },
-    };
+    return buildInvalidState(importSpecifier, resolvedPath);
   }
 
-  const clientId =
-    typeof companionModule.ANTIGRAVITY_CLIENT_ID === "string"
-      ? companionModule.ANTIGRAVITY_CLIENT_ID.trim()
-      : "";
-  const clientSecret =
-    typeof companionModule.ANTIGRAVITY_CLIENT_SECRET === "string"
-      ? companionModule.ANTIGRAVITY_CLIENT_SECRET.trim()
-      : "";
-
+  const clientId = normalizeCredential(companionModule.ANTIGRAVITY_CLIENT_ID);
+  const clientSecret = normalizeCredential(companionModule.ANTIGRAVITY_CLIENT_SECRET);
   if (!clientId || !clientSecret) {
-    return {
-      presence: {
-        state: "invalid",
-        importSpecifier: COMPANION_IMPORT_SPECIFIER,
-        resolvedPath,
-        error: COMPANION_INVALID_ERROR,
-      },
-      credentials: {
-        state: "invalid",
-        resolvedPath,
-        error: COMPANION_INVALID_ERROR,
-      },
-    };
+    return buildInvalidState(importSpecifier, resolvedPath);
+  }
+
+  return buildConfiguredState({ importSpecifier, resolvedPath, clientId, clientSecret });
+}
+
+async function tryRuntimeCredentialPaths(): Promise<ResolvedCompanionState | null> {
+  for (const candidatePath of getRuntimeCredentialPaths()) {
+    const resolved = await tryReadCredentialsPath(COMPANION_SOURCE_IMPORT_SPECIFIER, candidatePath);
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  return null;
+}
+
+async function tryResolveSourceConstants(
+  context: CompanionResolutionContext,
+): Promise<ResolvedCompanionState | null> {
+  let resolvedPath: string;
+  try {
+    resolvedPath = resolveCompanionSpecifier(COMPANION_SOURCE_IMPORT_SPECIFIER, context);
+  } catch (error) {
+    return isFallthroughResolutionError(error)
+      ? null
+      : buildInvalidState(COMPANION_SOURCE_IMPORT_SPECIFIER);
+  }
+
+  return (
+    (await tryReadCredentialsPath(COMPANION_SOURCE_IMPORT_SPECIFIER, resolvedPath)) ??
+    buildInvalidState(COMPANION_SOURCE_IMPORT_SPECIFIER, resolvedPath)
+  );
+}
+
+async function tryResolvePackageJson(
+  context: CompanionResolutionContext,
+): Promise<ResolvedCompanionState | null> {
+  let packageJsonPath: string;
+  try {
+    packageJsonPath = resolveCompanionSpecifier(COMPANION_PACKAGE_JSON_SPECIFIER, context);
+  } catch (error) {
+    return isFallthroughResolutionError(error)
+      ? null
+      : buildInvalidState(COMPANION_PACKAGE_JSON_SPECIFIER);
+  }
+
+  const packageRoot = dirname(packageJsonPath);
+  for (const candidatePath of getPackageCredentialPaths(packageRoot)) {
+    const resolved = await tryReadCredentialsPath(COMPANION_PACKAGE_JSON_SPECIFIER, candidatePath);
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  return buildInvalidState(COMPANION_PACKAGE_JSON_SPECIFIER, packageJsonPath);
+}
+
+async function tryResolvePackageEntry(
+  context: CompanionResolutionContext,
+): Promise<ResolvedCompanionState | null> {
+  let packageEntryPath: string;
+  try {
+    packageEntryPath = resolveCompanionSpecifier(COMPANION_PACKAGE_NAME, context);
+  } catch (error) {
+    return isFallthroughResolutionError(error)
+      ? null
+      : buildInvalidState(COMPANION_PACKAGE_NAME);
+  }
+
+  return (
+    (await tryReadCredentialsPath(COMPANION_PACKAGE_NAME, packageEntryPath)) ??
+    buildInvalidState(COMPANION_PACKAGE_NAME, packageEntryPath)
+  );
+}
+
+async function resolveCompanionState(): Promise<ResolvedCompanionState> {
+  const context: CompanionResolutionContext = { packageFound: false };
+
+  for (const importSpecifier of COMPANION_JS_IMPORT_SPECIFIERS) {
+    const resolved = await tryResolveJsConstants(importSpecifier, context);
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  const runtimeResolved = await tryRuntimeCredentialPaths();
+  if (runtimeResolved) {
+    return runtimeResolved;
+  }
+
+  const sourceResolved = await tryResolveSourceConstants(context);
+  if (sourceResolved) {
+    return sourceResolved;
+  }
+
+  const packageJsonResolved = await tryResolvePackageJson(context);
+  if (packageJsonResolved) {
+    return packageJsonResolved;
+  }
+
+  const packageEntryResolved = await tryResolvePackageEntry(context);
+  if (packageEntryResolved) {
+    return packageEntryResolved;
+  }
+
+  if (context.packageFound) {
+    return buildInvalidState(COMPANION_PACKAGE_NAME);
   }
 
   return {
     presence: {
-      state: "present",
-      importSpecifier: COMPANION_IMPORT_SPECIFIER,
-      resolvedPath,
+      state: "missing",
+      importSpecifier: COMPANION_SOURCE_IMPORT_SPECIFIER,
+      error: COMPANION_MISSING_ERROR,
     },
     credentials: {
-      state: "configured",
-      clientId,
-      clientSecret,
-      resolvedPath,
+      state: "missing",
+      error: COMPANION_MISSING_ERROR,
     },
   };
 }