@gpc-cli/cli 0.9.45 → 0.9.46

package/dist/doctor-H4X7Q57B.js

@@ -0,0 +1,691 @@
+#!/usr/bin/env node
+import {
+  green,
+  red,
+  yellow
+} from "./chunk-FAN4ZITI.js";
+import {
+  isNewerVersion
+} from "./chunk-3SJ6OXCZ.js";
+
+// src/commands/doctor.ts
+import { loadConfig, getCacheDir, getConfigDir } from "@gpc-cli/config";
+import { resolveAuth, AuthError } from "@gpc-cli/auth";
+import { existsSync, accessSync, statSync, constants } from "fs";
+import { readFile, stat, statfs } from "fs/promises";
+import { resolve, join } from "path";
+import { lookup } from "dns/promises";
+var PASS = "\u2713";
+var FAIL = "\u2717";
+var WARN = "\u26A0";
+var INFO = "-";
+var ANDROID_PACKAGE_RE = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "app",
+  "output",
+  "profile",
+  "auth",
+  "developerId",
+  "plugins",
+  "profiles",
+  "approvedPlugins",
+  "webhooks",
+  "debug",
+  "train"
+]);
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@gpc-cli/cli/latest";
+var API_HOST = "androidpublisher.googleapis.com";
+var REPORTING_HOST = "playdeveloperreporting.googleapis.com";
+var SA_KEY_ROTATION_DAYS = 90;
+function icon(status) {
+  switch (status) {
+    case "pass":
+      return green(PASS);
+    case "fail":
+      return red(FAIL);
+    case "warn":
+      return yellow(WARN);
+    case "info":
+      return INFO;
+  }
+}
+function checkNodeVersion(nodeVersion) {
+  const major = parseInt(nodeVersion.split(".")[0] ?? "0", 10);
+  return major >= 20 ? { name: "node", status: "pass", message: `Node.js ${nodeVersion}` } : {
+    name: "node",
+    status: "fail",
+    message: `Node.js ${nodeVersion} (requires >=20)`,
+    suggestion: "Upgrade Node.js to v20 or later: https://nodejs.org"
+  };
+}
+function checkPackageName(app) {
+  if (!app) return null;
+  return ANDROID_PACKAGE_RE.test(app) ? { name: "package-name", status: "pass", message: `Package name format OK: ${app}` } : {
+    name: "package-name",
+    status: "warn",
+    message: `Package name may be invalid: ${app}`,
+    suggestion: "Android package names must have 2+ dot-separated segments, each starting with a letter (e.g. com.example.app)"
+  };
+}
+function checkProxy(url) {
+  if (!url) return null;
+  try {
+    new URL(url);
+    return { name: "proxy", status: "pass", message: `Proxy configured: ${url}` };
+  } catch {
+    return {
+      name: "proxy",
+      status: "warn",
+      message: `Invalid proxy URL: ${url}`,
+      suggestion: "Set HTTPS_PROXY to a valid URL (e.g. http://proxy.example.com:8080)"
+    };
+  }
+}
+function checkDeveloperId(id) {
+  if (!id) return null;
+  if (/^\d+$/.test(id)) {
+    return { name: "developer-id", status: "pass", message: `Developer ID: ${id}` };
+  }
+  return {
+    name: "developer-id",
+    status: "warn",
+    message: `Developer ID may be invalid: ${id}`,
+    suggestion: "Developer IDs are numeric. Find yours at: Play Console \u2192 Settings \u2192 Developer account \u2192 Developer ID"
+  };
+}
+function checkConflictingCredentials(configSaPath) {
+  const sources = [];
+  if (configSaPath) sources.push("config file (auth.serviceAccount)");
+  if (process.env["GPC_SERVICE_ACCOUNT"]) sources.push("GPC_SERVICE_ACCOUNT env var");
+  if (process.env["GOOGLE_APPLICATION_CREDENTIALS"])
+    sources.push("GOOGLE_APPLICATION_CREDENTIALS env var");
+  if (sources.length <= 1) return null;
+  return {
+    name: "credentials-conflict",
+    status: "warn",
+    message: `Multiple credential sources: ${sources.join(", ")}`,
+    suggestion: "GPC uses the first match: config file \u2192 GPC_SERVICE_ACCOUNT \u2192 GOOGLE_APPLICATION_CREDENTIALS \u2192 ADC. Remove unused sources to avoid confusion."
+  };
+}
+function checkConfigKeys(config) {
+  const unknown = Object.keys(config).filter((k) => !KNOWN_CONFIG_KEYS.has(k));
+  if (unknown.length === 0) return null;
+  return {
+    name: "config-keys",
+    status: "warn",
+    message: `Unknown config key${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}`,
+    suggestion: `Valid keys: ${[...KNOWN_CONFIG_KEYS].sort().join(", ")}`
+  };
+}
+function checkCiEnvironment() {
+  if (!process.env["CI"]) return null;
+  let platform = "Unknown CI";
+  if (process.env["GITHUB_ACTIONS"]) platform = "GitHub Actions";
+  else if (process.env["GITLAB_CI"]) platform = "GitLab CI";
+  else if (process.env["BITBUCKET_PIPELINE_UUID"]) platform = "Bitbucket Pipelines";
+  else if (process.env["CIRCLECI"]) platform = "CircleCI";
+  else if (process.env["JENKINS_URL"]) platform = "Jenkins";
+  else if (process.env["TRAVIS"]) platform = "Travis CI";
+  else if (process.env["CODEBUILD_BUILD_ID"]) platform = "AWS CodeBuild";
+  else if (process.env["BUILD_BUILDID"]) platform = "Azure Pipelines";
+  const tips = [];
+  if (!process.env["GPC_NO_COLOR"]) tips.push("Set GPC_NO_COLOR=1 for clean logs");
+  if (!process.env["GPC_NO_UPDATE_CHECK"])
+    tips.push("Set GPC_NO_UPDATE_CHECK=1 to skip update checks");
+  return {
+    name: "ci",
+    status: "info",
+    message: `CI detected: ${platform}`,
+    suggestion: tips.length > 0 ? tips.join(". ") : void 0
+  };
+}
+async function checkGpcVersion() {
+  const currentVersion = "0.9.45";
+  if (currentVersion === "0.0.0") {
+    return { name: "version", status: "info", message: "GPC development build" };
+  }
+  try {
+    const resp = await fetch(NPM_REGISTRY_URL, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!resp.ok) return { name: "version", status: "pass", message: `GPC v${currentVersion}` };
+    const body = await resp.json();
+    if (!body.version)
+      return { name: "version", status: "pass", message: `GPC v${currentVersion}` };
+    if (isNewerVersion(currentVersion, body.version)) {
+      return {
+        name: "version",
+        status: "warn",
+        message: `GPC v${currentVersion} (v${body.version} available)`,
+        suggestion: "Run: gpc update"
+      };
+    }
+    return {
+      name: "version",
+      status: "pass",
+      message: `GPC v${currentVersion} (up to date)`
+    };
+  } catch {
+    return { name: "version", status: "pass", message: `GPC v${currentVersion}` };
+  }
+}
+async function checkDiskSpace(dir) {
+  try {
+    const stats = await statfs(dir);
+    const availableGB = Number(stats.bavail) * Number(stats.bsize) / 1024 ** 3;
+    if (availableGB < 0.1) {
+      return {
+        name: "disk-space",
+        status: "warn",
+        message: `Low disk space: ${availableGB.toFixed(1)} GB available`,
+        suggestion: "Free up disk space \u2014 AAB uploads can be up to 2 GB"
+      };
+    }
+    return {
+      name: "disk-space",
+      status: "pass",
+      message: `Disk space: ${availableGB.toFixed(1)} GB available`
+    };
+  } catch {
+    return { name: "disk-space", status: "info", message: "Could not check disk space" };
+  }
+}
+async function checkSaKeyAge(saPath) {
+  try {
+    const stats = await stat(saPath);
+    const ageDays = Math.floor((Date.now() - stats.mtimeMs) / (1e3 * 60 * 60 * 24));
+    if (ageDays > SA_KEY_ROTATION_DAYS) {
+      return {
+        name: "service-account-age",
+        status: "warn",
+        message: `Service account key is ${ageDays} days old`,
+        suggestion: `Google recommends rotating service account keys every ${SA_KEY_ROTATION_DAYS} days`
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function checkTokenCache(cacheDir) {
+  const cachePath = join(cacheDir, "token-cache.json");
+  try {
+    if (!existsSync(cachePath)) return null;
+    const content = await readFile(cachePath, "utf-8");
+    JSON.parse(content);
+    return { name: "token-cache", status: "pass", message: "Token cache OK" };
+  } catch {
+    return {
+      name: "token-cache",
+      status: "warn",
+      message: "Token cache is corrupt",
+      suggestion: "Clear with: gpc cache clear",
+      fixData: { path: cachePath }
+    };
+  }
+}
+async function probeHttps(host, timeoutMs = 5e3) {
+  const { connect } = await import("tls");
+  return new Promise((resolve2) => {
+    const start = performance.now();
+    const socket = connect({ host, port: 443 }, () => {
+      const latencyMs = Math.round(performance.now() - start);
+      socket.end();
+      resolve2({ ok: true, latencyMs });
+    });
+    socket.setTimeout(timeoutMs);
+    socket.on("error", (err) => {
+      socket.destroy();
+      resolve2({ ok: false, latencyMs: 0, error: err.message });
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve2({ ok: false, latencyMs: 0, error: "Connection timed out" });
+    });
+  });
+}
+async function checkAppAccess(packageName, accessToken) {
+  try {
+    const insertResp = await fetch(
+      `https://${API_HOST}/androidpublisher/v3/applications/${encodeURIComponent(packageName)}/edits`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({}),
+        signal: AbortSignal.timeout(1e4)
+      }
+    );
+    if (!insertResp.ok) {
+      const body = await insertResp.json().catch(() => ({}));
+      if (body.error?.status === "PERMISSION_DENIED" && body.error?.message?.includes("has not been used")) {
+        return {
+          name: "app-access",
+          status: "fail",
+          message: "Google Play Android Developer API is not enabled",
+          suggestion: "Enable it: https://console.cloud.google.com/apis/api/androidpublisher.googleapis.com"
+        };
+      }
+      if (insertResp.status === 403) {
+        return {
+          name: "app-access",
+          status: "fail",
+          message: `No access to ${packageName}`,
+          suggestion: "Grant the service account access in Google Play Console \u2192 Users and permissions"
+        };
+      }
+      if (insertResp.status === 404) {
+        return {
+          name: "app-access",
+          status: "fail",
+          message: `App not found: ${packageName}`,
+          suggestion: "Check the package name with: gpc config get app"
+        };
+      }
+      return {
+        name: "app-access",
+        status: "fail",
+        message: `App access check failed: HTTP ${insertResp.status}`,
+        suggestion: body.error?.message ?? "Check your credentials and app configuration"
+      };
+    }
+    const edit = await insertResp.json();
+    if (edit.id) {
+      await fetch(
+        `https://${API_HOST}/androidpublisher/v3/applications/${encodeURIComponent(packageName)}/edits/${edit.id}`,
+        {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${accessToken}` },
+          signal: AbortSignal.timeout(5e3)
+        }
+      ).catch(() => {
+      });
+    }
+    return {
+      name: "app-access",
+      status: "pass",
+      message: `App access verified: ${packageName}`
+    };
+  } catch (err) {
+    return {
+      name: "app-access",
+      status: "warn",
+      message: `Could not verify app access: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function applyFix(check) {
+  switch (check.name) {
+    case "config-dir":
+    case "cache-dir": {
+      const dirMatch = check.message.match(/: (.+)$/);
+      if (!dirMatch?.[1]) return null;
+      const { mkdir } = await import("fs/promises");
+      await mkdir(dirMatch[1], {
+        recursive: true,
+        mode: check.name === "cache-dir" ? 448 : 493
+      });
+      return `Created ${dirMatch[1]}`;
+    }
+    case "service-account-permissions": {
+      const saPath = check.fixData?.path;
+      if (!saPath) return null;
+      const { chmod } = await import("fs/promises");
+      await chmod(saPath, 384);
+      return `Fixed permissions on ${saPath}`;
+    }
+    case "token-cache": {
+      const cachePath = check.fixData?.path;
+      if (!cachePath) return null;
+      const { unlink } = await import("fs/promises");
+      await unlink(cachePath);
+      return `Cleared corrupt token cache`;
+    }
+    case "config": {
+      const { initConfig } = await import("@gpc-cli/config");
+      await initConfig({});
+      return "Initialized config file";
+    }
+    default:
+      return null;
+  }
+}
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Verify setup and connectivity").option("--fix", "Attempt to auto-fix failing checks").action(async (opts, cmd) => {
+    const results = [];
+    const parentOpts = cmd.parent?.opts() ?? {};
+    const jsonMode = !!(parentOpts["json"] || parentOpts["output"] === "json");
+    results.push(checkNodeVersion(process.versions.node));
+    results.push(await checkGpcVersion());
+    const ciResult = checkCiEnvironment();
+    if (ciResult) results.push(ciResult);
+    let config;
+    try {
+      config = await loadConfig();
+      results.push({ name: "config", status: "pass", message: "Configuration loaded" });
+      const keysCheck = checkConfigKeys(config);
+      if (keysCheck) results.push(keysCheck);
+      if (config.app) {
+        results.push({
+          name: "default-app",
+          status: "pass",
+          message: `Default app: ${config.app}`
+        });
+        const pkgCheck = checkPackageName(config.app);
+        if (pkgCheck) results.push(pkgCheck);
+      } else {
+        results.push({
+          name: "default-app",
+          status: "info",
+          message: "No default app configured",
+          suggestion: "Use --app flag or run: gpc config set app <package>"
+        });
+      }
+      const devIdCheck = checkDeveloperId(config.developerId);
+      if (devIdCheck) results.push(devIdCheck);
+    } catch {
+      results.push({
+        name: "config",
+        status: "fail",
+        message: "Configuration could not be loaded",
+        suggestion: "Run gpc config init to create a config file, or check .gpcrc.json for syntax errors"
+      });
+    }
+    const configDir = getConfigDir();
+    try {
+      if (existsSync(configDir)) {
+        accessSync(configDir, constants.R_OK | constants.W_OK);
+        results.push({
+          name: "config-dir",
+          status: "pass",
+          message: `Config directory: ${configDir}`
+        });
+      } else {
+        results.push({
+          name: "config-dir",
+          status: "info",
+          message: `Config directory does not exist yet: ${configDir}`
+        });
+      }
+    } catch {
+      results.push({
+        name: "config-dir",
+        status: "warn",
+        message: `Config directory not writable: ${configDir}`,
+        suggestion: `Fix permissions: chmod 755 ${configDir}`
+      });
+    }
+    const cacheDir = getCacheDir();
+    try {
+      if (existsSync(cacheDir)) {
+        accessSync(cacheDir, constants.R_OK | constants.W_OK);
+        results.push({
+          name: "cache-dir",
+          status: "pass",
+          message: `Cache directory: ${cacheDir}`
+        });
+      } else {
+        results.push({
+          name: "cache-dir",
+          status: "info",
+          message: `Cache directory does not exist yet: ${cacheDir}`
+        });
+      }
+    } catch {
+      results.push({
+        name: "cache-dir",
+        status: "warn",
+        message: `Cache directory not writable: ${cacheDir}`,
+        suggestion: `Fix permissions: chmod 700 ${cacheDir}`
+      });
+    }
+    const spaceDir = existsSync(cacheDir) ? cacheDir : configDir;
+    if (existsSync(spaceDir)) {
+      results.push(await checkDiskSpace(spaceDir));
+    }
+    let saFilePath;
+    if (config?.auth?.serviceAccount) {
+      const saValue = config.auth.serviceAccount;
+      const looksLikePath = !saValue.trim().startsWith("{");
+      if (looksLikePath) {
+        saFilePath = resolve(saValue);
+        if (existsSync(saFilePath)) {
+          try {
+            accessSync(saFilePath, constants.R_OK);
+            results.push({
+              name: "service-account-file",
+              status: "pass",
+              message: `Service account file: ${saFilePath}`
+            });
+          } catch {
+            results.push({
+              name: "service-account-file",
+              status: "fail",
+              message: `Service account file not readable: ${saFilePath}`,
+              suggestion: `Fix permissions: chmod 600 ${saFilePath}`
+            });
+          }
+          if (process.platform !== "win32") {
+            try {
+              const mode = statSync(saFilePath).mode;
+              const groupRead = (mode & 32) !== 0;
+              const worldRead = (mode & 4) !== 0;
+              if (groupRead || worldRead) {
+                results.push({
+                  name: "service-account-permissions",
+                  status: "warn",
+                  message: `Service account file is group/world-readable (mode: ${(mode & 511).toString(8)})`,
+                  suggestion: `Restrict permissions: chmod 600 ${saFilePath}`,
+                  fixData: { path: saFilePath }
+                });
+              } else {
+                results.push({
+                  name: "service-account-permissions",
+                  status: "pass",
+                  message: `Service account file permissions OK (mode: ${(mode & 511).toString(8)})`
+                });
+              }
+            } catch {
+            }
+          }
+          const ageResult = await checkSaKeyAge(saFilePath);
+          if (ageResult) results.push(ageResult);
+        } else {
+          results.push({
+            name: "service-account-file",
+            status: "fail",
+            message: `Service account file not found: ${saFilePath}`,
+            suggestion: "Check the path in your config or GPC_SERVICE_ACCOUNT env var"
+          });
+        }
+      }
+    }
+    const conflictCheck = checkConflictingCredentials(saFilePath);
+    if (conflictCheck) results.push(conflictCheck);
+    const cacheResult = await checkTokenCache(cacheDir);
+    if (cacheResult) results.push(cacheResult);
+    const gpcProfile = process.env["GPC_PROFILE"];
+    if (gpcProfile && config) {
+      if (config.profiles && gpcProfile in config.profiles) {
+        results.push({
+          name: "profile",
+          status: "pass",
+          message: `Profile "${gpcProfile}" found`
+        });
+      } else {
+        const available = config.profiles ? Object.keys(config.profiles).join(", ") : "";
+        results.push({
+          name: "profile",
+          status: "fail",
+          message: `Profile "${gpcProfile}" not found`,
+          suggestion: available ? `Available profiles: ${available}. Create with: gpc auth login --profile ${gpcProfile}` : `No profiles defined. Create one with: gpc auth login --profile ${gpcProfile}`
+        });
+      }
+    }
+    const proxyUrl = process.env["HTTPS_PROXY"] || process.env["https_proxy"] || process.env["HTTP_PROXY"] || process.env["http_proxy"];
+    const proxyCheck = checkProxy(proxyUrl);
+    if (proxyCheck) results.push(proxyCheck);
+    const caCert = process.env["GPC_CA_CERT"] || process.env["NODE_EXTRA_CA_CERTS"];
+    if (caCert) {
+      if (existsSync(caCert)) {
+        results.push({
+          name: "ca-cert",
+          status: "pass",
+          message: `CA certificate: ${caCert}`
+        });
+      } else {
+        results.push({
+          name: "ca-cert",
+          status: "warn",
+          message: `CA certificate file not found: ${caCert}`,
+          suggestion: "Check that GPC_CA_CERT points to an existing PEM file"
+        });
+      }
+    }
+    const dnsHosts = [API_HOST, REPORTING_HOST];
+    const dnsPassedHosts = [];
+    for (const host of dnsHosts) {
+      const label = host.split(".")[0];
+      try {
+        const start = performance.now();
+        await lookup(host);
+        const ms = Math.round(performance.now() - start);
+        results.push({
+          name: `dns-${label}`,
+          status: "pass",
+          message: `DNS: ${host} (${ms}ms)`
+        });
+        dnsPassedHosts.push(host);
+      } catch {
+        results.push({
+          name: `dns-${label}`,
+          status: "fail",
+          message: `Cannot resolve ${host}`,
+          suggestion: "Check your DNS settings and network connection"
+        });
+      }
+    }
+    for (const host of dnsPassedHosts) {
+      const label = host.split(".")[0];
+      const probe = await probeHttps(host);
+      if (probe.ok) {
+        results.push({
+          name: `https-${label}`,
+          status: "pass",
+          message: `HTTPS: ${host} (${probe.latencyMs}ms)`
+        });
+      } else {
+        results.push({
+          name: `https-${label}`,
+          status: "fail",
+          message: `HTTPS connection failed: ${host}`,
+          suggestion: probe.error ? `Error: ${probe.error}. Check firewall rules and proxy settings.` : "Check firewall rules and proxy settings"
+        });
+      }
+    }
+    let accessToken;
+    try {
+      const authConfig = config ?? await loadConfig();
+      const client = await resolveAuth({
+        serviceAccountPath: authConfig.auth?.serviceAccount
+      });
+      results.push({
+        name: "auth",
+        status: "pass",
+        message: `Authenticated as ${client.getClientEmail()}`
+      });
+      accessToken = await client.getAccessToken();
+      results.push({
+        name: "api-connectivity",
+        status: "pass",
+        message: "API connectivity verified"
+      });
+    } catch (error) {
+      if (error instanceof AuthError) {
+        results.push({
+          name: "auth",
+          status: "fail",
+          message: `Authentication: ${error.message}`,
+          suggestion: error.suggestion
+        });
+      } else {
+        const detail = error instanceof Error ? error.message : String(error);
+        results.push({
+          name: "api-connectivity",
+          status: "fail",
+          message: `API connectivity failed: ${detail}`,
+          suggestion: "Check your network connection and credentials"
+        });
+      }
+    }
+    if (accessToken && config?.app) {
+      results.push(await checkAppAccess(config.app, accessToken));
+    }
+    if (opts["fix"]) {
+      for (const r of results) {
+        if (r.status === "fail" || r.status === "warn") {
+          try {
+            const fixMsg = await applyFix(r);
+            if (fixMsg) {
+              console.log(`  ${green("\u2192")} Fixed: ${fixMsg}`);
+              r.status = "pass";
+              r.message += " (fixed)";
+            }
+          } catch (err) {
+            console.error(
+              `  ${red("\u2717")} Could not fix "${r.name}": ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+    }
+    const errors = results.filter((r) => r.status === "fail").length;
+    const warnings = results.filter((r) => r.status === "warn").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    if (jsonMode) {
+      const cleanResults = results.map(({ fixData: _, ...rest }) => rest);
+      console.log(
+        JSON.stringify(
+          { success: errors === 0, errors, warnings, checks: cleanResults },
+          null,
+          2
+        )
+      );
+      process.exitCode = errors > 0 ? 1 : 0;
+      return;
+    }
+    console.log("GPC Doctor\n");
+    for (const r of results) {
+      console.log(`  ${icon(r.status)} ${r.message}`);
+      if (r.suggestion && r.status !== "pass") {
+        console.log(`    ${r.suggestion}`);
+      }
+    }
+    console.log(
+      `
+  ${green(PASS)} ${passed} passed  ${yellow(WARN)} ${warnings} warning${warnings !== 1 ? "s" : ""}  ${red(FAIL)} ${errors} failed`
+    );
+    if (errors > 0) {
+      console.log("\nSome checks failed. Fix the issues above and run again.");
+      process.exitCode = 1;
+    } else if (warnings > 0) {
+      console.log("\nAll checks passed with warnings.");
+    } else {
+      console.log(`
+${green("\u2713")} Ready. Try: gpc status`);
+    }
+  });
+}
+export {
+  checkCiEnvironment,
+  checkConfigKeys,
+  checkConflictingCredentials,
+  checkDeveloperId,
+  checkNodeVersion,
+  checkPackageName,
+  checkProxy,
+  registerDoctorCommand
+};
+//# sourceMappingURL=doctor-H4X7Q57B.js.map