react-native-store-version 1.4.2 → 2.0.0

package/src/cli/checks/rollout.ts

@@ -0,0 +1,183 @@
+// C8: Android の段階公開の注意。Google Play の段階公開では、公開対象外のユーザーは新しい版を入手できない。
+// ストアの版との差分で force にしていると、その人たちはアプリを使えなくなる。ソースの簡易なテキスト検索で、
+// その設定になっていそうなときに注意を出す（誤検知はありうるので、--ignore C8 で抑止できることを書く）
+import { displayPath } from '../project/files.ts';
+import {
+  findOpeningTags,
+  maskSource,
+  readObjectLiteral,
+} from '../project/jsx.ts';
+import {
+  SCAN_LIMITS,
+  type ScanLimits,
+  scanSources,
+} from '../project/sources.ts';
+import type { CheckEntry } from '../result.ts';
+
+const PROVIDER = 'StoreVersionProvider';
+
+/** ストアの差分によらず版を渡す関数。どこかで使っていれば、force をストアの差分だけで決めていない */
+const VERSION_GETTERS = /\b(getLatestVersion|getMinimumVersion)\b/;
+
+/** 一覧に出すファイルの数（多いと 1 行が長くなりすぎる） */
+const MAX_LISTED = 5;
+
+const files = (n: number) => `${n} file${n === 1 ? '' : 's'}`;
+
+const listFiles = (files: readonly string[]): string =>
+  files.length > MAX_LISTED
+    ? `${files.slice(0, MAX_LISTED).join(', ')} and ${files.length - MAX_LISTED} more`
+    : files.join(', ');
+
+const ROLLOUT_NOTE =
+  "If you use a staged rollout on Google Play, users outside the rollout cannot get the new version, so a force update from the store version can leave them unable to use the app. When Platform.OS === 'android', set major: 'warning' in the policy, or control force with getMinimumVersion. This is a simple text search and may be a false positive (a policy that already uses major: 'warning' only on Android still has 'force' in it); if so, suppress it with --ignore C8";
+
+/** 理由の文言（`<StoreVersionProvider> …` に続く） */
+const REASONS = {
+  noPolicy: "has no policy prop (the default policy has major: 'force')",
+  spread: 'has no policy prop (it may come from a spread)',
+  force: "has 'force' in its policy",
+  noMajor:
+    "does not set major in its policy, so major updates use the default 'force'",
+  defaultPolicy: (expression: string) =>
+    `has policy={${expression}}, so the default policy (major: 'force') is used`,
+} as const;
+
+/** null / undefined は省略と同じで既定値になる */
+const isDefault = (expression: string): boolean =>
+  expression === 'undefined' || expression === 'null';
+
+/**
+ * policy 属性の値（`{…}` / `"…"` の書かれたまま）から、ストアの差分で force になりそうな理由。
+ * `'force'` / `"force"` があるか、`{undefined}` / `{null}`（既定の policy）か、オブジェクトリテラルで `major` が無い・
+ * null / undefined（既定の major は force）。変数や関数の policy は中身が分からないので、`'force'` の有無だけを見る。
+ * `...base` を含むオブジェクトは major がそこから来うるので、major の有無は見ない
+ */
+const policyReasons = (value: string | null): string[] => {
+  if (value === null) {
+    // 値の無い `policy`（true）。型の誤りで、判定の材料にならない
+    return [];
+  }
+  const reasons: string[] = [];
+  if (/'force'|"force"/.test(value)) {
+    reasons.push(REASONS.force);
+  }
+  if (!value.startsWith('{') || !value.endsWith('}')) {
+    return reasons;
+  }
+  const expression = maskSource(value.slice(1, -1), { strings: false }).trim();
+  if (isDefault(expression)) {
+    return [REASONS.defaultPolicy(expression)];
+  }
+  const object = readObjectLiteral(expression);
+  if (object !== null && !object.spread) {
+    const major = object.properties.get('major');
+    if (major === undefined || (major !== null && isDefault(major))) {
+      reasons.push(REASONS.noMajor);
+    }
+  }
+  return reasons;
+};
+
+/**
+ * 1 つのファイルの `<StoreVersionProvider …>` の開始タグのうち、ストアの差分で force になりそうなものの理由
+ * （policy 属性が無い = デフォルトの major が force。{@link policyReasons}）。重複は 1 つにする
+ */
+const forceReasons = (source: string): string[] => {
+  const reasons = new Set<string>();
+  for (const tag of findOpeningTags(source, PROVIDER)) {
+    const policy = tag.attributes.find(({ name }) => name === 'policy');
+    if (policy === undefined) {
+      reasons.add(tag.spreads > 0 ? REASONS.spread : REASONS.noPolicy);
+      continue;
+    }
+    for (const reason of policyReasons(policy.value)) {
+      reasons.add(reason);
+    }
+  }
+  return [...reasons];
+};
+
+/**
+ * C8。Android の package が特定できたときだけ（無ければ skipped）。`<cwd>` の下のソースを走査し、
+ * `<StoreVersionProvider>` の開始タグが force になりそうなファイルごとに warning。ただし `getLatestVersion` /
+ * `getMinimumVersion` が走査したどこかのファイルにあれば、どれも出さない。ファイル数の上限を超えたら判定せずに info
+ */
+export const checkRollout = (
+  cwd: string,
+  androidPackage: string | null,
+  limits: ScanLimits = SCAN_LIMITS
+): CheckEntry[] => {
+  if (androidPackage === null) {
+    return [
+      {
+        id: 'C8',
+        level: 'skipped',
+        message:
+          'no Android package was determined, so the staged rollout note does not apply',
+      },
+    ];
+  }
+
+  const flagged: { file: string; reasons: string[] }[] = [];
+  let getterFile: string | null = null;
+  const scan = scanSources(
+    cwd,
+    (path, source) => {
+      // コメントの中の名前（`// TODO: getMinimumVersion を使う`）は使っていることにならない
+      if (
+        getterFile === null &&
+        VERSION_GETTERS.test(maskSource(source, { strings: false }))
+      ) {
+        getterFile = displayPath(cwd, path);
+      }
+      if (source.includes(PROVIDER)) {
+        const reasons = forceReasons(source);
+        if (reasons.length > 0) {
+          flagged.push({ file: displayPath(cwd, path), reasons });
+        }
+      }
+    },
+    limits
+  );
+
+  if (scan.truncated) {
+    return [
+      {
+        id: 'C8',
+        level: 'info',
+        message: `stopped scanning the sources at ${files(limits.maxFiles)} (.ts / .tsx / .js / .jsx outside node_modules, ios, android, and build output), so the staged rollout note was not checked. Check --cwd, or suppress this with --ignore C8`,
+      },
+    ];
+  }
+
+  const entries: CheckEntry[] = [];
+  if (scan.tooLarge.length > 0) {
+    entries.push({
+      id: 'C8',
+      level: 'info',
+      message: `did not scan ${scan.tooLarge.length} source ${scan.tooLarge.length === 1 ? 'file' : 'files'} larger than ${limits.maxFileBytes} bytes: ${listFiles(scan.tooLarge.map((path) => displayPath(cwd, path)))}`,
+    });
+  }
+
+  if (getterFile !== null || flagged.length === 0) {
+    entries.push({
+      id: 'C8',
+      level: 'ok',
+      message:
+        getterFile !== null
+          ? `getLatestVersion / getMinimumVersion is used (${getterFile}), so force updates do not depend only on the store version`
+          : `no <${PROVIDER}> that forces updates from the store version was found (${files(scan.scanned)} scanned)`,
+    });
+    return entries;
+  }
+
+  for (const { file, reasons } of flagged) {
+    entries.push({
+      id: 'C8',
+      level: 'warning',
+      message: `${file}: <${PROVIDER}> ${reasons.join(' / ')}, and getLatestVersion / getMinimumVersion is not used in the sources. ${ROLLOUT_NOTE}`,
+    });
+  }
+  return entries;
+};

package/src/cli/checks/store.ts

@@ -0,0 +1,105 @@
+// C3: その ID でストアから引けるか。ストアの取得はライブラリ本体の fetcher をそのまま使う
+// （アプリが起動時に使うのと同じ取得先・同じ抽出）
+import { StoreVersionError } from '../../errors.ts';
+import { fetchAndroidVersion } from '../../fetchers/android.ts';
+import { lookupIOS } from '../../fetchers/ios.ts';
+import type { CheckEntry } from '../result.ts';
+
+/** C3 の 1 回の取得のタイムアウト（ms） */
+export const STORE_TIMEOUT_MS = 10_000;
+
+/** C3 で引く ID。無い（null / undefined / 空文字）プラットフォームは飛ばす */
+export type StoreIds = {
+  /** iOS の bundleId */
+  ios?: string | null;
+  /** Android の package name */
+  android?: string | null;
+};
+
+const describeError = (error: unknown): string =>
+  error instanceof StoreVersionError
+    ? `${error.code}: ${error.message}`
+    : error instanceof Error
+      ? error.message
+      : String(error);
+
+const androidFailure = (packageName: string, error: unknown): string => {
+  const code = error instanceof StoreVersionError ? error.code : undefined;
+  if (code === 'NOT_FOUND') {
+    return `package "${packageName}" is not found on Google Play: not published yet, a wrong ID, or not available in the country of this network`;
+  }
+  // ページは取れたが版を比較できない（Varies with device / `50616-r-2026-11-03` のような版）。アプリの起動時の判定でも
+  // ストアの版は使えない（INVALID_VERSION で onError になり UI を出さない）ので、取り直しても直らない失敗として分ける
+  if (code === 'INVALID_VERSION') {
+    return `package "${packageName}" is on Google Play, but its version cannot be compared (${(error as StoreVersionError).message}). The store version cannot drive force / warning updates, so use getLatestVersion / getMinimumVersion`;
+  }
+  return `could not get package "${packageName}" from Google Play (access from CI can be unstable): ${describeError(error)}`;
+};
+
+/**
+ * C3。ID ごとにストアを引き、見つかれば ok（ストアの版を添える）、失敗はすべて warning
+ * （`NOT_FOUND` は「ストアに見つからない」。ほかの失敗も、CI からのストア、特に Play Store へのアクセスは不安定なので error にしない）。
+ * Android の `INVALID_VERSION`（Google Play にはあるが版を比較できない）は、getLatestVersion / getMinimumVersion を勧める文面にする
+ * （iOS の lookupIOS は版を検証しないので INVALID_VERSION にならない）。ID が 1 つも無ければ skipped
+ */
+export const checkStore = async (
+  ids: StoreIds,
+  { country }: { country: string }
+): Promise<CheckEntry[]> => {
+  const tasks: Promise<CheckEntry>[] = [];
+
+  if (ids.ios) {
+    const bundleId = ids.ios;
+    const where = `the App Store (${country})`;
+    tasks.push(
+      lookupIOS({ bundleId }, country, { timeoutMs: STORE_TIMEOUT_MS }).then(
+        ({ version }): CheckEntry => ({
+          id: 'C3',
+          level: 'ok',
+          message: `bundleId "${bundleId}" is on ${where} (version ${version})`,
+        }),
+        (error: unknown): CheckEntry => ({
+          id: 'C3',
+          level: 'warning',
+          message:
+            error instanceof StoreVersionError && error.code === 'NOT_FOUND'
+              ? `bundleId "${bundleId}" is not found on ${where}: not published yet, a wrong ID, or not available in that country`
+              : `could not look up bundleId "${bundleId}" on ${where}: ${describeError(error)}`,
+        })
+      )
+    );
+  }
+
+  if (ids.android) {
+    const packageName = ids.android;
+    tasks.push(
+      fetchAndroidVersion(
+        { packageName },
+        { timeoutMs: STORE_TIMEOUT_MS }
+      ).then(
+        ({ version }): CheckEntry => ({
+          id: 'C3',
+          level: 'ok',
+          message: `package "${packageName}" is on Google Play (version ${version})`,
+        }),
+        (error: unknown): CheckEntry => ({
+          id: 'C3',
+          level: 'warning',
+          message: androidFailure(packageName, error),
+        })
+      )
+    );
+  }
+
+  if (tasks.length === 0) {
+    return [
+      {
+        id: 'C3',
+        level: 'skipped',
+        message: 'no iOS bundleId or Android package to look up',
+      },
+    ];
+  }
+  // 各 task は reject しない（失敗は then の第 2 引数で warning にしている）
+  return Promise.all(tasks);
+};

package/src/cli/checks/versions.ts

@@ -0,0 +1,108 @@
+// C4: ローカルの版（Expo の設定の version・iOS・Android）が一致しているか。
+// ストアの版と比べる「ローカルの版」はプラットフォームごとにアプリへ入る値なので、ずれていると片方だけ判定が変わる
+import type { Found } from '../project/files.ts';
+import type { ProjectInfo } from '../project/index.ts';
+import type { CheckEntry } from '../result.ts';
+
+type Source = {
+  /** `iOS` / `Android` / `Expo` */
+  name: string;
+  /** 見つかった値。見つからなければ理由 */
+  found: Found | null;
+  reason: string;
+};
+
+const describe = (name: string, { label, value, file }: Found) =>
+  `${name} ${label} ${value} (${file})`;
+
+/**
+ * C4。ネイティブのディレクトリ（`ios/` / `android/`）がどちらも無い（CNG）なら skipped（指摘ではないので注釈にしない）。
+ * iOS と Android（ネイティブ同士）、Expo の設定の version と各ネイティブを比べ、ずれている組ごとに warning。
+ * 特定できないネイティブの値は、その値を含む比較を飛ばして info（Expo の version が書かれていなければ黙って比べない）。比べる組が無ければ skipped。比較は文字列の一致
+ * （`1.0` と `1.0.0` もずれとして出す。ストアに出る値の書き方を揃えるため）
+ */
+export const checkVersions = (project: ProjectInfo): CheckEntry[] => {
+  if (project.ios === null && project.android === null) {
+    return [
+      {
+        id: 'C4',
+        level: 'skipped',
+        message:
+          'there is no ios/ or android/ directory (Continuous Native Generation), so there are no native versions to compare',
+      },
+    ];
+  }
+
+  const sources: Source[] = [];
+  for (const [name, lookup] of [
+    ['iOS', project.ios?.version],
+    ['Android', project.android?.version],
+  ] as const) {
+    if (lookup !== undefined) {
+      sources.push(
+        lookup.value === null
+          ? { name, found: null, reason: lookup.reason }
+          : { name, found: lookup, reason: '' }
+      );
+    }
+  }
+  // Expo の設定の version は任意（書かなければ Expo が package.json の値で補う。expo.ts の writtenVersion）なので、
+  // 書かれていないときは比べず、info も出さない（bare RN に expo を入れただけのアプリで毎回出るのを避ける）
+  const config = project.expo?.config;
+  if (config && config.version !== null) {
+    sources.push({
+      name: 'Expo',
+      found: { label: 'version', value: config.version, file: config.file },
+      reason: '',
+    });
+  }
+
+  const entries: CheckEntry[] = [];
+  for (const { name, found, reason } of sources) {
+    if (found === null) {
+      entries.push({
+        id: 'C4',
+        level: 'info',
+        message: `could not determine the ${name} version (${reason}), so it is not compared`,
+      });
+    }
+  }
+
+  const known = sources.filter(
+    (source): source is Source & { found: Found } => source.found !== null
+  );
+  if (known.length < 2) {
+    if (entries.length === 0) {
+      entries.push({
+        id: 'C4',
+        level: 'skipped',
+        message: `only one version was found (${known.map(({ name, found }) => describe(name, found)).join('')}), so there is nothing to compare`,
+      });
+    }
+    return entries;
+  }
+
+  let differs = false;
+  for (let i = 0; i < known.length; i += 1) {
+    for (let j = i + 1; j < known.length; j += 1) {
+      const a = known[i];
+      const b = known[j];
+      if (a.found.value !== b.found.value) {
+        differs = true;
+        entries.push({
+          id: 'C4',
+          level: 'warning',
+          message: `${describe(a.name, a.found)} differs from ${describe(b.name, b.found)}`,
+        });
+      }
+    }
+  }
+  if (!differs) {
+    entries.push({
+      id: 'C4',
+      level: 'ok',
+      message: `the versions match: ${known.map(({ name, found }) => describe(name, found)).join(', ')}`,
+    });
+  }
+  return entries;
+};

package/src/cli/index.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// CLI の入口（package.json の bin。Node 専用で、アプリのバンドルには入らない。exports からは辿れない）。
+// ここでは Node の版だけを確かめ、満たすときだけ本体（main.ts）を読み込む。ESM の static import は巻き上げられて
+// この判定より先に評価される（古い Node では本体が使う API の読み込みで先に落ちうる）ので、ほかのモジュールを
+// static に import しない（__tests__/cli/index.test.ts でソースを読んで確かめている）
+
+/** CLI が動く Node の最低の版（package.json の engines には書かない） */
+export const MIN_NODE_VERSION = '22.14.0';
+
+/**
+ * `process.versions.node`（`22.14.0` など）が {@link MIN_NODE_VERSION} 以上か。major / minor だけを見る。
+ * 比較のモジュールも import しないため、手で分ける。読めない値は満たさない扱い
+ */
+export const isSupportedNode = (version: string): boolean => {
+  const [major, minor] = version.split('.').map((part) => Number(part));
+  if (!Number.isInteger(major) || !Number.isInteger(minor)) {
+    return false;
+  }
+  return major > 22 || (major === 22 && minor >= 14);
+};
+
+const start = async (): Promise<void> => {
+  const current = process.versions.node;
+  if (!isSupportedNode(current)) {
+    const message = `the CLI requires Node.js ${MIN_NODE_VERSION} or later (current: ${current})`;
+    process.stderr.write(`react-native-store-version: ${message}\n`);
+    // GitHub Actions 上では、ログの stderr だけでは理由が PR の画面に出ないので注釈も出す（main.ts の失敗と同じ title）。
+    // output.ts の escapeData は import できない（上のとおり）ので、同じ最小限のエスケープ（`%` を最初に）をここで行う
+    if (process.env.GITHUB_ACTIONS === 'true') {
+      const escaped = message
+        .replace(/%/g, '%25')
+        .replace(/\r/g, '%0D')
+        .replace(/\n/g, '%0A');
+      process.stderr.write(
+        `::error title=react-native-store-version check::${escaped}\n`
+      );
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const { main } = await import('./main.ts');
+  await main();
+};
+
+// main() は自分で失敗を受けて終了コードにするので、ここに来るのは本体の読み込みの失敗だけ
+start().catch((error: unknown) => {
+  process.stderr.write(
+    `react-native-store-version: ${error instanceof Error ? error.message : String(error)}\n`
+  );
+  process.exitCode = 1;
+});

package/src/cli/main.ts

@@ -0,0 +1,229 @@
+// CLI の本体（index.ts が Node の版を確かめてから読み込む）。引数の解析・チェックの実行・出力・終了コード。
+// Node の標準モジュールと、react-native を読まないライブラリ本体のファイルだけを使う（CLI のための依存は足さない）
+import { appendFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { runChecks } from './check.ts';
+import {
+  formatGithub,
+  formatGithubFailure,
+  formatJson,
+  formatSummary,
+  formatText,
+  oneLine,
+  type Report,
+} from './output.ts';
+import { countEntries, exitCodeOf } from './result.ts';
+
+/** C3 の App Store の国の既定 */
+export const DEFAULT_COUNTRY = 'us';
+
+/** `--help` の出力 */
+export const USAGE = `Usage: react-native-store-version check [options]
+
+Checks the setup of react-native-store-version in an app.
+
+Options:
+  --cwd <dir>       the app directory (default: the current directory)
+  --json            print the result as JSON
+  --strict          exit with 1 on warnings too
+  --ignore <ids>    comma-separated checks not to run (e.g. C4,C8)
+  --country <xx>    the App Store country for C3 (default: ${DEFAULT_COUNTRY})
+  -h, --help        show this help
+`;
+
+/** {@link run} が使う外界（テストから差し替える） */
+export type RunContext = {
+  /** `--cwd` の相対パスの起点と既定 */
+  cwd: string;
+  env: Readonly<Record<string, string | undefined>>;
+  stdout: (text: string) => void;
+  stderr: (text: string) => void;
+};
+
+const errorMessage = (error: unknown) =>
+  error instanceof Error ? error.message : String(error);
+
+/** 引数の誤り。使い方と一緒に stderr に出し、終了コード 1 にする */
+class UsageError extends Error {}
+
+type CheckArgs = {
+  cwd: string;
+  json: boolean;
+  strict: boolean;
+  ignore: Set<string>;
+  country: string;
+};
+
+const parseIgnore = (values: readonly string[]): Set<string> => {
+  const ids = new Set<string>();
+  for (const value of values) {
+    for (const part of value.split(',')) {
+      const id = part.trim().toUpperCase();
+      if (id === '') {
+        continue;
+      }
+      // ID の形だけを見る（無い ID は何も止めないだけなので、誤りにはしない）
+      if (!/^C\d+$/.test(id)) {
+        throw new UsageError(
+          `--ignore: ${JSON.stringify(part.trim())} is not a check ID (e.g. C1)`
+        );
+      }
+      ids.add(id);
+    }
+  }
+  return ids;
+};
+
+const parse = (argv: readonly string[]) =>
+  parseArgs({
+    args: [...argv],
+    allowPositionals: true,
+    strict: true,
+    options: {
+      cwd: { type: 'string' },
+      json: { type: 'boolean' },
+      strict: { type: 'boolean' },
+      ignore: { type: 'string', multiple: true },
+      country: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+
+/** 引数を解析する。`--help` なら null */
+const parseCheckArgs = (
+  argv: readonly string[],
+  context: RunContext
+): CheckArgs | null => {
+  let parsed: ReturnType<typeof parse>;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    // parseArgs の誤り（不明なオプション・値の無い --cwd など）
+    throw new UsageError(errorMessage(error));
+  }
+  const { values, positionals } = parsed;
+  if (values.help) {
+    return null;
+  }
+  const [command, ...rest] = positionals;
+  if (command === undefined) {
+    throw new UsageError('no command given');
+  }
+  if (command !== 'check') {
+    throw new UsageError(`unknown command: ${command}`);
+  }
+  if (rest.length > 0) {
+    throw new UsageError(`unexpected argument: ${rest[0]}`);
+  }
+
+  const cwd = resolve(context.cwd, values.cwd ?? '.');
+  let isDirectory = false;
+  try {
+    isDirectory = statSync(cwd).isDirectory();
+  } catch {
+    // 無いパスも、下でディレクトリでない扱いにする
+  }
+  if (!isDirectory) {
+    throw new UsageError(`--cwd: ${cwd} is not a directory`);
+  }
+
+  const country = values.country ?? DEFAULT_COUNTRY;
+  // iTunes Lookup の country は 2 文字の国コード
+  if (!/^[A-Za-z]{2}$/.test(country)) {
+    throw new UsageError(
+      `--country: ${JSON.stringify(country)} is not a 2-letter country code`
+    );
+  }
+
+  return {
+    cwd,
+    json: values.json ?? false,
+    strict: values.strict ?? false,
+    ignore: parseIgnore(values.ignore ?? []),
+    country: country.toLowerCase(),
+  };
+};
+
+/**
+ * CLI を引数 `argv`（`process.argv.slice(2)`）で動かし、終了コードを返す。例外は投げない
+ * （引数の誤り・想定外の失敗は stderr に出して 1。GitHub Actions 上では stderr に `::error::` の注釈も出し、
+ * stdout には何も出さない（`--json` の stdout を JSON 以外で汚さないため。runner は stderr のコマンドも処理する））
+ */
+export const run = async (
+  argv: readonly string[],
+  context: RunContext
+): Promise<number> => {
+  const onGithub = context.env.GITHUB_ACTIONS === 'true';
+  const fail = (message: string, usage: boolean): 1 => {
+    // GitHub Actions 上では、message の改行で次の行がワークフローコマンドにならないよう 1 行にする
+    const line = onGithub ? oneLine(message) : message;
+    context.stderr(`error: ${line}\n${usage ? `\n${USAGE}` : ''}`);
+    if (onGithub) {
+      context.stderr(formatGithubFailure(message));
+    }
+    return 1;
+  };
+
+  let args: CheckArgs | null;
+  try {
+    args = parseCheckArgs(argv, context);
+  } catch (error) {
+    return fail(errorMessage(error), true);
+  }
+  if (args === null) {
+    context.stdout(USAGE);
+    return 0;
+  }
+
+  let report: Report;
+  try {
+    const entries = await runChecks({
+      cwd: args.cwd,
+      country: args.country,
+      ignore: args.ignore,
+    });
+    const counts = countEntries(entries);
+    report = {
+      cwd: args.cwd,
+      entries,
+      counts,
+      exitCode: exitCodeOf(counts, args.strict),
+    };
+  } catch (error) {
+    return fail(errorMessage(error), false);
+  }
+
+  if (args.json) {
+    // stdout は JSON だけにする（GitHub Actions 上でも注釈を混ぜない）
+    context.stdout(formatJson(report));
+  } else if (onGithub) {
+    context.stdout(formatGithub(report));
+  } else {
+    context.stdout(formatText(report));
+  }
+  // Job Summary はファイルへの追記で stdout を汚さないので、--json でも書く
+  const summary = context.env.GITHUB_STEP_SUMMARY;
+  if (onGithub && summary) {
+    try {
+      appendFileSync(summary, formatSummary(report));
+    } catch (error) {
+      // Job Summary は付け足しの表示なので、書けなくてもチェックの結果（終了コード）は変えない
+      context.stderr(
+        `warning: could not write the job summary: ${errorMessage(error)}\n`
+      );
+    }
+  }
+  return report.exitCode;
+};
+
+/** `process` につないで {@link run} を動かす（index.ts から呼ぶ） */
+export const main = async (): Promise<void> => {
+  process.exitCode = await run(process.argv.slice(2), {
+    cwd: process.cwd(),
+    env: process.env,
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+  });
+};