storemeta 0.1.0

package/.env.release.example

@@ -0,0 +1,8 @@
+# Copy this file to .env.release.local and fill real local values.
+# .env.release.local is ignored by .gitignore through the .env.* rule.
+
+STORE_APPLE_ISSUER_ID=00000000-0000-0000-0000-000000000000
+STORE_APPLE_KEY_ID=XXXXXXXXXX
+STORE_APPLE_PRIVATE_KEY_PATH=/absolute/path/to/AuthKey_XXXXXXXXXX.p8
+
+STORE_GOOGLE_SERVICE_ACCOUNT_PATH=/absolute/path/to/google-service-account.json

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# storemeta
+
+`storemeta` is a TypeScript CLI for pulling, validating, and pushing App Store Connect and Google Play metadata and screenshots.
+
+## Install
+
+```bash
+npm install -g storemeta
+```
+
+Requirements:
+- Node.js 20+
+
+## Quick Start
+
+Create a starter project:
+
+```bash
+storemeta init
+```
+
+Validate local config, metadata, and screenshot layout:
+
+```bash
+storemeta validate
+```
+
+Create missing locale metadata files and screenshot folders from config:
+
+```bash
+storemeta scaffold
+```
+
+Pull metadata from one platform:
+
+```bash
+storemeta metadata pull --platform apple
+storemeta metadata pull --platform google --locale en-US
+```
+
+Pull screenshots from one platform:
+
+```bash
+storemeta screenshots pull --platform apple
+storemeta screenshots pull --platform google --locale en-US
+```
+
+Push local metadata or screenshots:
+
+```bash
+storemeta metadata push --platform google --dry-run
+storemeta screenshots push --platform apple --replace
+```
+
+## Implemented Commands
+
+- `storemeta init`
+- `storemeta validate`
+- `storemeta auth check`
+- `storemeta config doctor`
+- `storemeta locales list`
+- `storemeta scaffold`
+- `storemeta metadata pull`
+- `storemeta metadata push`
+- `storemeta metadata diff`
+- `storemeta screenshots pull`
+- `storemeta screenshots push`
+- `storemeta screenshots diff`
+
+## Example Project
+
+A safe, fake sample project lives under [`examples/`](examples).
+
+## Documentation
+
+The current user and config documentation is here:
+
+- [DOCUMENTATION.md](docs/DOCUMENTATION.md)
+
+The original implementation plan is kept here:
+
+- [PROJECT_PLAN.md](docs/PROJECT_PLAN.md)
+
+Release verification notes:
+
+- [RELEASE_VERIFICATION.md](docs/RELEASE_VERIFICATION.md)
+
+Credential setup:
+
+- [AUTH_SETUP.md](docs/AUTH_SETUP.md)
+
+Security notes:
+
+- [SECURITY.md](SECURITY.md)

package/dist/auth/apple/credential-state.js

@@ -0,0 +1,14 @@
+import { createCredentialFieldState, } from "../credential-state.js";
+import { loadAppleCredentials } from "./load-credentials.js";
+export function getAppleCredentialState(credentials, env = process.env) {
+    const loaded = loadAppleCredentials(credentials, env);
+    const issuerId = createCredentialFieldState(credentials.issuerIdEnv, loaded.issuerId);
+    const keyId = createCredentialFieldState(credentials.keyIdEnv, loaded.keyId);
+    const privateKeyPath = createCredentialFieldState(credentials.privateKeyPathEnv, loaded.privateKeyPath);
+    return {
+        issuerId,
+        keyId,
+        privateKeyPath,
+        allPresent: issuerId.present && keyId.present && privateKeyPath.present,
+    };
+}

package/dist/auth/apple/jwt.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { importPKCS8, SignJWT } from "jose";
+import { StoremetaError } from "../../cli/errors.js";
+import { requireAppleCredentials } from "./load-credentials.js";
+export const APPLE_APP_STORE_CONNECT_AUDIENCE = "appstoreconnect-v1";
+const DEFAULT_APPLE_TOKEN_TTL_SECONDS = 15 * 60;
+const MAX_APPLE_TOKEN_TTL_SECONDS = 20 * 60;
+function resolveAppleTokenIssuedAt(now) {
+    if (now instanceof Date) {
+        return Math.floor(now.getTime() / 1000);
+    }
+    if (typeof now === "number") {
+        return Math.floor(now);
+    }
+    return Math.floor(Date.now() / 1000);
+}
+function resolveAppleTokenTtlSeconds(expiresInSeconds) {
+    const ttlSeconds = expiresInSeconds ?? DEFAULT_APPLE_TOKEN_TTL_SECONDS;
+    if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+        throw new StoremetaError("AUTH_ERROR", "Apple JWT expiration must be a positive number of seconds");
+    }
+    if (ttlSeconds > MAX_APPLE_TOKEN_TTL_SECONDS) {
+        throw new StoremetaError("AUTH_ERROR", `Apple JWT expiration must not exceed ${MAX_APPLE_TOKEN_TTL_SECONDS} seconds`);
+    }
+    return Math.floor(ttlSeconds);
+}
+export async function createAppleJwtToken(credentials, env = process.env, options) {
+    const resolvedCredentials = requireAppleCredentials(credentials, env);
+    const issuedAt = resolveAppleTokenIssuedAt(options?.now);
+    const ttlSeconds = resolveAppleTokenTtlSeconds(options?.expiresInSeconds);
+    let privateKeyPem;
+    try {
+        privateKeyPem = await readFile(resolvedCredentials.privateKeyPath, "utf8");
+    }
+    catch (cause) {
+        throw new StoremetaError("AUTH_ERROR", `Failed to read Apple private key file at ${resolvedCredentials.privateKeyPath}`, { cause });
+    }
+    try {
+        const privateKey = await importPKCS8(privateKeyPem, "ES256");
+        return await new SignJWT({
+            iss: resolvedCredentials.issuerId,
+            aud: APPLE_APP_STORE_CONNECT_AUDIENCE,
+        })
+            .setProtectedHeader({
+            alg: "ES256",
+            kid: resolvedCredentials.keyId,
+            typ: "JWT",
+        })
+            .setIssuedAt(issuedAt)
+            .setExpirationTime(issuedAt + ttlSeconds)
+            .sign(privateKey);
+    }
+    catch (cause) {
+        throw new StoremetaError("AUTH_ERROR", "Failed to sign Apple JWT from the configured private key", { cause });
+    }
+}

package/dist/auth/apple/load-credentials.js

@@ -0,0 +1,36 @@
+import { StoremetaError } from "../../cli/errors.js";
+function hasText(value) {
+    return value !== undefined && value.trim().length > 0;
+}
+export function loadAppleCredentials(credentials, env = process.env) {
+    return {
+        issuerId: env[credentials.issuerIdEnv],
+        keyId: env[credentials.keyIdEnv],
+        privateKeyPath: env[credentials.privateKeyPathEnv],
+    };
+}
+export function requireAppleCredentials(credentials, env = process.env) {
+    const loaded = loadAppleCredentials(credentials, env);
+    const missing = [];
+    if (!hasText(loaded.issuerId)) {
+        missing.push(credentials.issuerIdEnv);
+    }
+    if (!hasText(loaded.keyId)) {
+        missing.push(credentials.keyIdEnv);
+    }
+    if (!hasText(loaded.privateKeyPath)) {
+        missing.push(credentials.privateKeyPathEnv);
+    }
+    if (missing.length > 0) {
+        throw new StoremetaError("AUTH_ERROR", `Missing Apple credentials in environment: ${missing.join(", ")}`);
+    }
+    const { issuerId, keyId, privateKeyPath } = loaded;
+    if (!hasText(issuerId) || !hasText(keyId) || !hasText(privateKeyPath)) {
+        throw new StoremetaError("AUTH_ERROR", "Apple credential resolution failed unexpectedly after validation");
+    }
+    return {
+        issuerId,
+        keyId,
+        privateKeyPath,
+    };
+}

package/dist/auth/credential-state.js

@@ -0,0 +1,6 @@
+export function createCredentialFieldState(envVar, value) {
+    return {
+        envVar,
+        present: value !== undefined && value.trim().length > 0,
+    };
+}

package/dist/auth/google/credential-state.js

@@ -0,0 +1,10 @@
+import { createCredentialFieldState, } from "../credential-state.js";
+import { loadGoogleCredentials } from "./load-credentials.js";
+export function getGoogleCredentialState(credentials, env = process.env) {
+    const loaded = loadGoogleCredentials(credentials, env);
+    const serviceAccountPath = createCredentialFieldState(credentials.serviceAccountPathEnv, loaded.serviceAccountPath);
+    return {
+        serviceAccountPath,
+        allPresent: serviceAccountPath.present,
+    };
+}

package/dist/auth/google/load-credentials.js

@@ -0,0 +1,18 @@
+import { StoremetaError } from "../../cli/errors.js";
+function hasText(value) {
+    return value !== undefined && value.trim().length > 0;
+}
+export function loadGoogleCredentials(credentials, env = process.env) {
+    return {
+        serviceAccountPath: env[credentials.serviceAccountPathEnv],
+    };
+}
+export function requireGoogleCredentials(credentials, env = process.env) {
+    const loaded = loadGoogleCredentials(credentials, env);
+    if (!hasText(loaded.serviceAccountPath)) {
+        throw new StoremetaError("AUTH_ERROR", `Missing Google credentials in environment: ${credentials.serviceAccountPathEnv}`);
+    }
+    return {
+        serviceAccountPath: loaded.serviceAccountPath,
+    };
+}

package/dist/auth/google/service-account-auth.js

@@ -0,0 +1,25 @@
+import { GoogleAuth } from "google-auth-library";
+import { StoremetaError } from "../../cli/errors.js";
+import { requireGoogleCredentials } from "./load-credentials.js";
+export const GOOGLE_PLAY_SCOPE = "https://www.googleapis.com/auth/androidpublisher";
+export function createGoogleServiceAccountAuth(credentials, env = process.env) {
+    const resolvedCredentials = requireGoogleCredentials(credentials, env);
+    return new GoogleAuth({
+        keyFile: resolvedCredentials.serviceAccountPath,
+        scopes: [GOOGLE_PLAY_SCOPE],
+    });
+}
+export async function getGoogleAccessToken(credentials, env = process.env) {
+    const auth = createGoogleServiceAccountAuth(credentials, env);
+    const client = await auth.getClient();
+    const accessTokenResult = await client.getAccessToken();
+    const accessToken = typeof accessTokenResult === "string"
+        ? accessTokenResult
+        : accessTokenResult?.token;
+    if (accessToken === undefined ||
+        accessToken === null ||
+        accessToken.trim().length === 0) {
+        throw new StoremetaError("AUTH_ERROR", "Failed to obtain a Google Play access token from the service account");
+    }
+    return accessToken;
+}

package/dist/auth/redact.js

@@ -0,0 +1,17 @@
+export const REDACTED_SECRET = "[REDACTED]";
+function hasPresentValue(value) {
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    return value !== undefined && value !== null;
+}
+export function redactSecretValue(value, replacement = REDACTED_SECRET) {
+    return hasPresentValue(value) ? replacement : value;
+}
+export function redactSecretFields(record, secretKeys, replacement = REDACTED_SECRET) {
+    const redacted = { ...record };
+    for (const key of secretKeys) {
+        redacted[key] = redactSecretValue(record[key], replacement);
+    }
+    return redacted;
+}

package/dist/cli/auth-check.js

@@ -0,0 +1,46 @@
+import { getAppleCredentialState } from "../auth/apple/credential-state.js";
+import { getGoogleCredentialState } from "../auth/google/credential-state.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { createCommandContext } from "./context.js";
+function createSummary(results) {
+    const failureCount = results.filter((result) => !result.success).length;
+    const successCount = results.length - failureCount;
+    return {
+        status: failureCount === 0 ? "success" : successCount === 0 ? "failure" : "partial",
+        successCount,
+        failureCount,
+        skippedCount: 0,
+        results,
+    };
+}
+export async function runAuthCheckCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const results = [];
+    for (const platform of platforms) {
+        if (platform === "apple" && context.app.settings.apple !== undefined) {
+            const state = getAppleCredentialState(context.app.settings.apple.credentials);
+            const missing = [state.issuerId, state.keyId, state.privateKeyPath]
+                .filter((field) => !field.present)
+                .map((field) => field.envVar);
+            results.push({
+                target: "auth.apple",
+                success: missing.length === 0,
+                message: missing.length === 0
+                    ? "Apple credential environment variables are present"
+                    : `Missing Apple credential environment variables: ${missing.join(", ")}`,
+            });
+        }
+        if (platform === "google" && context.app.settings.google !== undefined) {
+            const state = getGoogleCredentialState(context.app.settings.google.credentials);
+            results.push({
+                target: "auth.google",
+                success: state.allPresent,
+                message: state.allPresent
+                    ? "Google credential environment variables are present"
+                    : `Missing Google credential environment variable: ${state.serviceAccountPath.envVar}`,
+            });
+        }
+    }
+    return createSummary(results);
+}

package/dist/cli/config-doctor.js

@@ -0,0 +1,40 @@
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { createCommandContext } from "./context.js";
+export async function runConfigDoctorCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const results = [
+        {
+            target: "config",
+            success: true,
+            message: `Loaded ${context.configPath}`,
+        },
+        {
+            target: "project",
+            success: true,
+            message: `${context.config.project.name}; default app ${context.config.project.defaultApp}`,
+        },
+        {
+            target: `app.${context.app.id}`,
+            success: true,
+            message: `Selected platforms: ${platforms.join(", ") || "none"}`,
+        },
+        {
+            target: "metadata.baseDir",
+            success: true,
+            message: context.app.settings.metadata.baseDir,
+        },
+        {
+            target: "screenshots.baseDir",
+            success: true,
+            message: context.app.settings.screenshots.baseDir,
+        },
+    ];
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}

package/dist/cli/context.js

@@ -0,0 +1,23 @@
+import { loadConfigFile } from "../config/load-config.js";
+import { validateRootConfig } from "../config/schema.js";
+import { selectConfiguredApp } from "../config/select-app.js";
+import { validateBaseDirectoryPaths } from "../config/validate-base-dirs.js";
+import { validateCredentialEnvVarNames } from "../config/validate-credential-env-names.js";
+import { validateRequiredPlatformIdentifiers } from "../config/validate-platform-identifiers.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+export async function createCommandContext(options) {
+    const loadedConfig = await loadConfigFile(options.config);
+    const config = validateRootConfig(loadedConfig.parsed);
+    validateRequiredPlatformIdentifiers(config);
+    validateCredentialEnvVarNames(config);
+    validateBaseDirectoryPaths(config);
+    return {
+        configPath: loadedConfig.path,
+        config,
+        app: selectConfiguredApp(config, options.app),
+        platform: options.platform,
+        locale: options.locale === undefined ? undefined : normalizeLocaleCode(options.locale),
+        dryRun: options.dryRun ?? false,
+        verbose: options.verbose ?? false,
+    };
+}

package/dist/cli/errors.js

@@ -0,0 +1,10 @@
+export class StoremetaError extends Error {
+    code;
+    cause;
+    constructor(code, message, options) {
+        super(message);
+        this.name = "StoremetaError";
+        this.code = code;
+        this.cause = options?.cause;
+    }
+}

package/dist/cli/exit-code.js

@@ -0,0 +1,6 @@
+export function applyCommandSummaryExitCode(summary, processLike = process) {
+    if (summary.status === "success") {
+        return;
+    }
+    processLike.exitCode = 1;
+}

package/dist/cli/init.js

@@ -0,0 +1,60 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { StoremetaError } from "./errors.js";
+import { DEFAULT_CONFIG_FILE } from "../config/load-config.js";
+export function renderStarterConfig() {
+    return `version: 1
+
+project:
+  name: example-project
+  defaultApp: example-app
+
+apps:
+  example-app:
+    metadata:
+      baseDir: metadata
+      format: yaml
+    screenshots:
+      baseDir: screenshots
+
+    apple:
+      appId: "0000000000"
+      credentials:
+        issuerIdEnv: STORE_APPLE_ISSUER_ID
+        keyIdEnv: STORE_APPLE_KEY_ID
+        privateKeyPathEnv: STORE_APPLE_PRIVATE_KEY_PATH
+      locales:
+        default: [en-US]
+
+    google:
+      packageName: com.example.app
+      credentials:
+        serviceAccountPathEnv: STORE_GOOGLE_SERVICE_ACCOUNT_PATH
+      locales:
+        default: [en-US]
+`;
+}
+export async function runInitCommand(configPath) {
+    const resolvedPath = resolve(configPath ?? DEFAULT_CONFIG_FILE);
+    const projectRoot = dirname(resolvedPath);
+    try {
+        await access(resolvedPath);
+        throw new StoremetaError("FILESYSTEM_ERROR", `Refusing to overwrite existing config file at ${resolvedPath}`);
+    }
+    catch (error) {
+        if (error instanceof StoremetaError ||
+            (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                error.code !== "ENOENT")) {
+            throw error;
+        }
+    }
+    await mkdir(projectRoot, { recursive: true });
+    await writeFile(resolvedPath, renderStarterConfig(), "utf8");
+    await mkdir(join(projectRoot, "metadata", "apple"), { recursive: true });
+    await mkdir(join(projectRoot, "metadata", "google"), { recursive: true });
+    await mkdir(join(projectRoot, "screenshots", "apple", "en-US", "APP_IPHONE_65"), { recursive: true });
+    await mkdir(join(projectRoot, "screenshots", "google", "en-US", "phoneScreenshots"), { recursive: true });
+    return resolvedPath;
+}

package/dist/cli/locales-list.js

@@ -0,0 +1,37 @@
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createCommandContext } from "./context.js";
+function formatLocales(locales) {
+    if (locales === undefined || locales.length === 0) {
+        return "none configured";
+    }
+    return locales.map(normalizeLocaleCode).join(", ");
+}
+export async function runLocalesListCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const results = [];
+    for (const platform of platforms) {
+        if (platform === "apple" && context.app.settings.apple !== undefined) {
+            results.push({
+                target: "locales.apple",
+                success: true,
+                message: formatLocales(context.app.settings.apple.locales?.default),
+            });
+        }
+        if (platform === "google" && context.app.settings.google !== undefined) {
+            results.push({
+                target: "locales.google",
+                success: true,
+                message: formatLocales(context.app.settings.google.locales?.default),
+            });
+        }
+    }
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}

package/dist/cli/metadata-diff.js

@@ -0,0 +1,57 @@
+import { readdir } from "node:fs/promises";
+import { dirname, extname, resolve } from "node:path";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createCommandContext } from "./context.js";
+async function listMetadataLocales(platformDir) {
+    try {
+        const entries = await readdir(platformDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .filter((fileName) => [".yml", ".yaml", ".md"].includes(extname(fileName)))
+            .map((fileName) => normalizeLocaleCode(fileName.slice(0, -extname(fileName).length)))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+function expectedLocalesForPlatform(context, platform) {
+    const locales = platform === "apple"
+        ? context.app.settings.apple?.locales?.default
+        : context.app.settings.google?.locales?.default;
+    return (locales ?? []).map(normalizeLocaleCode).sort((left, right) => left.localeCompare(right));
+}
+export async function runMetadataDiffCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const metadataBaseDir = resolve(dirname(context.configPath), context.app.settings.metadata.baseDir);
+    const results = [];
+    for (const platform of platforms) {
+        const expected = expectedLocalesForPlatform(context, platform);
+        const actual = await listMetadataLocales(resolve(metadataBaseDir, platform));
+        const missing = expected.filter((locale) => !actual.includes(locale));
+        const extra = actual.filter((locale) => expected.length > 0 && !expected.includes(locale));
+        results.push({
+            target: `metadata.${platform}`,
+            success: missing.length === 0,
+            message: [
+                `local: ${actual.length === 0 ? "none" : actual.join(", ")}`,
+                expected.length === 0 ? "expected: not configured" : `expected: ${expected.join(", ")}`,
+                missing.length === 0 ? undefined : `missing: ${missing.join(", ")}`,
+                extra.length === 0 ? undefined : `extra: ${extra.join(", ")}`,
+            ]
+                .filter((part) => part !== undefined)
+                .join("; "),
+        });
+    }
+    const failureCount = results.filter((result) => !result.success).length;
+    return {
+        status: failureCount === 0 ? "success" : "partial",
+        successCount: results.length - failureCount,
+        failureCount,
+        skippedCount: 0,
+        results,
+    };
+}

package/dist/cli/metadata-pull.js

@@ -0,0 +1,52 @@
+import { dirname, resolve } from "node:path";
+import { StoremetaError } from "./errors.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createAppStoreConnectClient } from "../platforms/apple/client.js";
+import { fetchAppleAppInfoLocalizations, fetchAppleAppStoreVersionLocalizations, mergeAppleLocalizations, normalizeMergedAppleLocalizations, writeAppleMetadataDocuments, } from "../platforms/apple/metadata/pull.js";
+import { createGooglePlayClient } from "../platforms/google/client.js";
+import { withGoogleEditSession } from "../platforms/google/edits.js";
+import { fetchGoogleListingsForLocales, normalizeGoogleListing, writeGoogleListingDocuments, } from "../platforms/google/metadata/pull.js";
+import { createCommandContext } from "./context.js";
+function filterLocalizedDocumentsByLocale(documents, locale) {
+    if (locale === undefined) {
+        return documents;
+    }
+    const normalizedLocale = normalizeLocaleCode(locale);
+    return documents.filter((document) => normalizeLocaleCode(document.locale) === normalizedLocale);
+}
+export async function runMetadataPullCommand(options) {
+    const context = await createCommandContext(options);
+    const app = context.app;
+    const selectedPlatforms = resolveSelectedPlatforms(app, context.platform);
+    const metadataBaseDir = resolve(dirname(context.configPath), app.settings.metadata.baseDir);
+    for (const platform of selectedPlatforms) {
+        if (platform === "apple") {
+            const appleSettings = app.settings.apple;
+            if (appleSettings === undefined) {
+                throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define App Store Connect settings`);
+            }
+            const client = createAppStoreConnectClient(appleSettings.credentials);
+            const appInfoLocalizations = await fetchAppleAppInfoLocalizations(client, appleSettings.appId);
+            const appStoreVersionLocalizations = await fetchAppleAppStoreVersionLocalizations(client, appleSettings.appId);
+            const documents = filterLocalizedDocumentsByLocale(normalizeMergedAppleLocalizations(mergeAppleLocalizations(appInfoLocalizations, appStoreVersionLocalizations)), context.locale);
+            await writeAppleMetadataDocuments(metadataBaseDir, documents);
+            continue;
+        }
+        const googleSettings = app.settings.google;
+        if (googleSettings === undefined) {
+            throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define Google Play settings`);
+        }
+        const locales = context.locale
+            ? [normalizeLocaleCode(context.locale)]
+            : (googleSettings.locales?.default ?? []).map(normalizeLocaleCode);
+        const client = createGooglePlayClient(googleSettings.credentials);
+        await withGoogleEditSession(client, googleSettings.packageName, async (edit) => {
+            const listings = await fetchGoogleListingsForLocales(client, googleSettings.packageName, edit.id, locales);
+            const documents = listings.map(normalizeGoogleListing);
+            await writeGoogleListingDocuments(metadataBaseDir, documents);
+        }, {
+            autoCommit: false,
+        });
+    }
+}