@extension.dev/deploy 0.1.0

package/dist/module.mjs

@@ -0,0 +1,886 @@
+import { z } from "zod";
+import promises_default from "node:fs/promises";
+import external_node_crypto_default from "node:crypto";
+const chromeOptionsSchema = z.object({
+    zip: z.string().min(1),
+    extensionId: z.string().min(1).trim(),
+    clientId: z.string().min(1).trim(),
+    clientSecret: z.string().min(1).trim(),
+    refreshToken: z.string().min(1).trim(),
+    publishTarget: z["enum"]([
+        "default",
+        "trustedTesters"
+    ]).default("default"),
+    deployPercentage: z.number().int().min(1).max(100).optional(),
+    reviewExemption: z.boolean().default(false),
+    skipSubmitReview: z.boolean().default(false)
+});
+const firefoxOptionsSchema = z.object({
+    zip: z.string().min(1),
+    sourcesZip: z.string().min(1).optional(),
+    extensionId: z.string().min(1).trim(),
+    jwtIssuer: z.string().min(1).trim(),
+    jwtSecret: z.string().min(1).trim(),
+    channel: z["enum"]([
+        "listed",
+        "unlisted"
+    ]).default("listed")
+});
+const edgeOptionsSchema = z.object({
+    zip: z.string().min(1),
+    productId: z.string().min(1).trim(),
+    clientId: z.string().min(1).trim(),
+    apiKey: z.string().min(1).trim(),
+    skipSubmitReview: z.boolean().default(false)
+});
+const deployConfigSchema = z.object({
+    dryRun: z.boolean().default(false),
+    chrome: chromeOptionsSchema.optional(),
+    firefox: firefoxOptionsSchema.optional(),
+    edge: edgeOptionsSchema.optional()
+});
+function resolveConfig(flags) {
+    const dryRun = flags.dryRun ?? envBool("DRY_RUN") ?? false;
+    const chromeZip = flags.chromeZip ?? envStr("CHROME_ZIP");
+    const firefoxZip = flags.firefoxZip ?? envStr("FIREFOX_ZIP");
+    const edgeZip = flags.edgeZip ?? envStr("EDGE_ZIP");
+    return {
+        dryRun,
+        chrome: null == chromeZip ? void 0 : {
+            zip: chromeZip,
+            extensionId: flags.chromeExtensionId ?? envStr("CHROME_EXTENSION_ID") ?? "",
+            clientId: flags.chromeClientId ?? envStr("CHROME_CLIENT_ID") ?? "",
+            clientSecret: flags.chromeClientSecret ?? envStr("CHROME_CLIENT_SECRET") ?? "",
+            refreshToken: flags.chromeRefreshToken ?? envStr("CHROME_REFRESH_TOKEN") ?? "",
+            publishTarget: flags.chromePublishTarget ?? envStr("CHROME_PUBLISH_TARGET"),
+            deployPercentage: flags.chromeDeployPercentage ?? envInt("CHROME_DEPLOY_PERCENTAGE"),
+            reviewExemption: flags.chromeReviewExemption ?? envBool("CHROME_REVIEW_EXEMPTION"),
+            skipSubmitReview: flags.chromeSkipSubmitReview ?? envBool("CHROME_SKIP_SUBMIT_REVIEW")
+        },
+        firefox: null == firefoxZip ? void 0 : {
+            zip: firefoxZip,
+            sourcesZip: flags.firefoxSourcesZip ?? envStr("FIREFOX_SOURCES_ZIP"),
+            extensionId: flags.firefoxExtensionId ?? envStr("FIREFOX_EXTENSION_ID") ?? "",
+            jwtIssuer: flags.firefoxJwtIssuer ?? envStr("FIREFOX_JWT_ISSUER") ?? "",
+            jwtSecret: flags.firefoxJwtSecret ?? envStr("FIREFOX_JWT_SECRET") ?? "",
+            channel: flags.firefoxChannel ?? envStr("FIREFOX_CHANNEL")
+        },
+        edge: null == edgeZip ? void 0 : {
+            zip: edgeZip,
+            productId: flags.edgeProductId ?? envStr("EDGE_PRODUCT_ID") ?? "",
+            clientId: flags.edgeClientId ?? envStr("EDGE_CLIENT_ID") ?? "",
+            apiKey: flags.edgeApiKey ?? envStr("EDGE_API_KEY") ?? "",
+            skipSubmitReview: flags.edgeSkipSubmitReview ?? envBool("EDGE_SKIP_SUBMIT_REVIEW")
+        }
+    };
+}
+function pathToEnvName(segments) {
+    return segments.map((s)=>String(s).replace(/[A-Z]/g, (ch)=>`_${ch}`).toUpperCase()).join("_");
+}
+const SETUP_HINTS = {
+    CHROME_EXTENSION_ID: "Find this in the Chrome Web Store Developer Dashboard URL for your extension.",
+    CHROME_CLIENT_ID: "Create OAuth 2.0 credentials at https://console.cloud.google.com/apis/credentials",
+    CHROME_CLIENT_SECRET: "Generated alongside the Client ID in the Google Cloud Console.",
+    CHROME_REFRESH_TOKEN: "Obtain by completing the OAuth consent flow. See the Chrome Web Store API docs.",
+    CHROME_ZIP: "Path to the .zip file built for Chrome Web Store upload.",
+    FIREFOX_EXTENSION_ID: "The addon GUID ({uuid} format) or email-style ID from your addon's AMO page.",
+    FIREFOX_JWT_ISSUER: "API key from https://addons.mozilla.org/developers/addon/api/key/",
+    FIREFOX_JWT_SECRET: "API secret generated alongside the JWT issuer on AMO.",
+    FIREFOX_ZIP: "Path to the .zip file built for Firefox AMO upload.",
+    EDGE_PRODUCT_ID: "Product ID from the Edge Partner Center dashboard.",
+    EDGE_CLIENT_ID: "Client ID from the Edge Partner Center API settings.",
+    EDGE_API_KEY: "API key (v1.1) from https://partner.microsoft.com/dashboard/microsoftedge/publishapi",
+    EDGE_ZIP: "Path to the .zip file built for Edge Partner Center upload."
+};
+function validateConfig(raw) {
+    const result = deployConfigSchema.safeParse(raw);
+    if (!result.success) {
+        const lines = result.error.issues.map((issue)=>{
+            const envName = pathToEnvName(issue.path);
+            const hint = SETUP_HINTS[envName];
+            const base = `  - ${envName}: ${issue.message}`;
+            return hint ? `${base}\n    ${hint}` : base;
+        });
+        throw new Error([
+            "Missing required config. Set via CLI flags or environment variables:",
+            ...lines,
+            "",
+            "Tip: create a .env.submit file in your project root, or pass --help for all flags."
+        ].join("\n"));
+    }
+    return result.data;
+}
+function envBool(name) {
+    const val = process.env[name];
+    return null == val ? void 0 : "true" === val;
+}
+function envStr(name) {
+    const val = process.env[name];
+    return val || void 0;
+}
+function envInt(name) {
+    const val = process.env[name];
+    return null == val ? void 0 : parseInt(val, 10);
+}
+async function fetchJson(url, init) {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+        const body = await res.text().catch(()=>"");
+        throw new Error(`HTTP ${res.status} ${res.statusText} \u{2014} ${(null == init ? void 0 : init.method) ?? "GET"} ${url}\n${body}`);
+    }
+    return res.json();
+}
+async function fetchRaw(url, init) {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+        const body = await res.text().catch(()=>"");
+        throw new Error(`HTTP ${res.status} ${res.statusText} \u{2014} ${(null == init ? void 0 : init.method) ?? "GET"} ${url}\n${body}`);
+    }
+    return res;
+}
+async function assertFilePresent(filePath) {
+    try {
+        await promises_default.access(filePath);
+    } catch  {
+        throw new Error(`File not found: ${filePath}`);
+    }
+}
+async function getFileSize(filePath) {
+    const stat = await promises_default.stat(filePath);
+    return stat.size;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+function log(store, message) {
+    const tag = `[${store}]`;
+    console.log(`${tag} ${message}`);
+}
+function logDryStep(store, step, details) {
+    const tag = `[${store}] DRY RUN`;
+    console.log(`${tag} \u{2192} ${step}`);
+    if (details) {
+        for (const [key, value] of Object.entries(details))if (null != value) console.log(`${tag}     ${key}: ${value}`);
+    }
+}
+const CWS_OAUTH_URL = "https://oauth2.googleapis.com/token";
+const CWS_UPLOAD_BASE = "https://www.googleapis.com/upload/chromewebstore/v1.1/items";
+const CWS_PUBLISH_BASE = "https://www.googleapis.com/chromewebstore/v1.1/items";
+const CWS_ITEMS_BASE = "https://www.googleapis.com/chromewebstore/v1.1/items";
+function chromeStoreUrl(extensionId) {
+    return `https://chromewebstore.google.com/detail/${extensionId}`;
+}
+async function authenticate(clientId, clientSecret, refreshToken) {
+    return fetchJson(CWS_OAUTH_URL, {
+        method: "POST",
+        body: JSON.stringify({
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: refreshToken,
+            grant_type: "refresh_token",
+            redirect_uri: "urn:ietf:wg:oauth:2.0:oob"
+        }),
+        headers: {
+            "Content-Type": "application/json"
+        }
+    });
+}
+async function chrome_upload(extensionId, zipPath, token) {
+    const body = await promises_default.readFile(zipPath);
+    const res = await fetch(`${CWS_UPLOAD_BASE}/${extensionId}`, {
+        method: "PUT",
+        body,
+        headers: {
+            Authorization: `${token.token_type} ${token.access_token}`,
+            "x-goog-api-version": "2",
+            "Content-Type": "application/zip"
+        }
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(()=>"");
+        throw new Error(`Chrome upload failed: ${res.status} ${res.statusText}\n${text}`);
+    }
+}
+async function publish(params) {
+    const url = new URL(`${CWS_PUBLISH_BASE}/${params.extensionId}/publish`);
+    url.searchParams.set("publishTarget", params.publishTarget);
+    if (null != params.deployPercentage) url.searchParams.set("deployPercentage", String(params.deployPercentage));
+    if (null != params.reviewExemption) url.searchParams.set("reviewExemption", String(params.reviewExemption));
+    const res = await fetch(url.href, {
+        method: "POST",
+        headers: {
+            Authorization: `${params.token.token_type} ${params.token.access_token}`,
+            "x-goog-api-version": "2",
+            "Content-Length": "0"
+        }
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(()=>"");
+        throw new Error(`Chrome publish failed: ${res.status} ${res.statusText}\n${text}`);
+    }
+}
+async function publishChrome(options, dryRun) {
+    await assertFilePresent(options.zip);
+    const zipSize = await getFileSize(options.zip);
+    log("chrome", "Authenticating with Chrome Web Store");
+    const token = await authenticate(options.clientId, options.clientSecret, options.refreshToken);
+    const outcome = {
+        storeUrl: chromeStoreUrl(options.extensionId),
+        submissionId: options.extensionId
+    };
+    if (dryRun) {
+        logDryStep("chrome", "Authentication succeeded", {
+            tokenType: token.token_type,
+            scope: "chromewebstore"
+        });
+        logDryStep("chrome", "Would upload ZIP", {
+            file: options.zip,
+            size: formatBytes(zipSize),
+            target: `${CWS_UPLOAD_BASE}/${options.extensionId}`,
+            method: "PUT"
+        });
+        options.skipSubmitReview ? logDryStep("chrome", "Would skip publish (skipSubmitReview=true)") : logDryStep("chrome", "Would publish for review", {
+            target: `${CWS_PUBLISH_BASE}/${options.extensionId}/publish`,
+            publishTarget: options.publishTarget ?? "default",
+            deployPercentage: options.deployPercentage,
+            reviewExemption: options.reviewExemption
+        });
+        log("chrome", "Dry run complete \u2014 no changes made");
+        return outcome;
+    }
+    log("chrome", `Uploading ZIP file (${formatBytes(zipSize)})`);
+    await chrome_upload(options.extensionId, options.zip, token);
+    if (options.skipSubmitReview) {
+        log("chrome", "Skipping publish step (skipSubmitReview=true)");
+        return outcome;
+    }
+    log("chrome", "Publishing extension");
+    await publish({
+        extensionId: options.extensionId,
+        publishTarget: options.publishTarget,
+        token,
+        deployPercentage: options.deployPercentage,
+        reviewExemption: options.reviewExemption
+    });
+    return outcome;
+}
+async function getChromeItem(params) {
+    const token = await authenticate(params.clientId, params.clientSecret, params.refreshToken);
+    const url = `${CWS_ITEMS_BASE}/${encodeURIComponent(params.extensionId)}?projection=${params.projection ?? "DRAFT"}`;
+    return fetchJson(url, {
+        headers: {
+            Authorization: `${token.token_type} ${token.access_token}`,
+            "x-goog-api-version": "2"
+        }
+    });
+}
+async function verifyChromeCredentials(params) {
+    let token;
+    try {
+        token = await authenticate(params.clientId, params.clientSecret, params.refreshToken);
+    } catch (err) {
+        return {
+            ok: false,
+            message: `OAuth token exchange failed. Verify your Client ID, Client Secret, and Refresh Token are correct.\n${err instanceof Error ? err.message : err}`
+        };
+    }
+    try {
+        const item = await fetchJson(`${CWS_ITEMS_BASE}/${encodeURIComponent(params.extensionId)}?projection=DRAFT`, {
+            headers: {
+                Authorization: `${token.token_type} ${token.access_token}`
+            }
+        });
+        const title = (null == item ? void 0 : item.title) || params.extensionId;
+        return {
+            ok: true,
+            message: `Credentials verified. You have access to "${title}".`,
+            extensionTitle: title
+        };
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("404")) return {
+            ok: false,
+            message: "Extension ID not found. Verify the ID is correct and belongs to your account."
+        };
+        if (msg.includes("403")) return {
+            ok: false,
+            message: `Access denied to extension ${params.extensionId}. You may not be the owner or a developer on this item.`
+        };
+        return {
+            ok: false,
+            message: `Chrome Web Store API check failed: ${msg}`
+        };
+    }
+}
+function delay(ms) {
+    return new Promise((resolve)=>{
+        setTimeout(resolve, ms);
+    });
+}
+const AMO_BASE = "https://addons.mozilla.org/api/v5/addons";
+const AMO_PROFILE_URL = "https://addons.mozilla.org/api/v5/accounts/profile/";
+const POLL_INTERVAL_MS = 5000;
+const VALIDATION_TIMEOUT_MS = 600000;
+function firefoxStoreUrl(addonIdOrSlug) {
+    return `https://addons.mozilla.org/firefox/addon/${addonIdOrSlug}`;
+}
+function signJwt(issuer, secret, expiresInSeconds = 30) {
+    const header = {
+        alg: "HS256",
+        typ: "JWT"
+    };
+    const now = Math.floor(Date.now() / 1000);
+    const payload = {
+        iss: issuer,
+        jti: Math.random().toString(),
+        iat: now,
+        exp: now + expiresInSeconds
+    };
+    const b64 = (obj)=>Buffer.from(JSON.stringify(obj)).toString("base64url");
+    const segments = `${b64(header)}.${b64(payload)}`;
+    const sig = external_node_crypto_default.createHmac("sha256", secret).update(segments).digest("base64url");
+    return `${segments}.${sig}`;
+}
+function authHeaders(jwtIssuer, jwtSecret) {
+    return {
+        Authorization: `JWT ${signJwt(jwtIssuer, jwtSecret)}`
+    };
+}
+function getAddon(addonId, jwtIssuer, jwtSecret) {
+    return fetchJson(`${AMO_BASE}/addon/${addonId}`, {
+        headers: authHeaders(jwtIssuer, jwtSecret)
+    });
+}
+async function createUpload(zipPath, channel, jwtIssuer, jwtSecret) {
+    const buf = await promises_default.readFile(zipPath);
+    const blob = new Blob([
+        buf
+    ], {
+        type: "application/zip"
+    });
+    const form = new FormData();
+    form.set("channel", channel);
+    form.set("upload", blob, "extension.zip");
+    return fetchJson(`${AMO_BASE}/upload/`, {
+        method: "POST",
+        body: form,
+        headers: authHeaders(jwtIssuer, jwtSecret)
+    });
+}
+function getUpload(uuid, jwtIssuer, jwtSecret) {
+    return fetchJson(`${AMO_BASE}/upload/${uuid}`, {
+        headers: authHeaders(jwtIssuer, jwtSecret)
+    });
+}
+async function createVersion(params) {
+    const form = new FormData();
+    form.set("upload", params.uploadUuid);
+    if (params.sourcesZip) {
+        const srcBuf = await promises_default.readFile(params.sourcesZip);
+        const srcBlob = new Blob([
+            srcBuf
+        ], {
+            type: "application/zip"
+        });
+        form.set("source", srcBlob, "sources.zip");
+    } else form.set("source", "");
+    return fetchJson(`${AMO_BASE}/addon/${params.addonId}/versions/`, {
+        method: "POST",
+        body: form,
+        headers: authHeaders(params.jwtIssuer, params.jwtSecret)
+    });
+}
+async function publishFirefox(options, dryRun) {
+    await assertFilePresent(options.zip);
+    const zipSize = await getFileSize(options.zip);
+    let sourcesSize;
+    if (options.sourcesZip) {
+        await assertFilePresent(options.sourcesZip);
+        sourcesSize = await getFileSize(options.sourcesZip);
+    }
+    const addonId = normalizeAddonId(options.extensionId);
+    const { jwtIssuer, jwtSecret } = options;
+    log("firefox", "Verifying addon exists");
+    await getAddon(addonId, jwtIssuer, jwtSecret);
+    const outcome = {
+        storeUrl: firefoxStoreUrl(addonId),
+        submissionId: addonId
+    };
+    if (dryRun) {
+        logDryStep("firefox", "Addon verified", {
+            addonId
+        });
+        logDryStep("firefox", "Would upload ZIP", {
+            file: options.zip,
+            size: formatBytes(zipSize),
+            channel: options.channel ?? "listed",
+            target: `${AMO_BASE}/upload/`,
+            method: "POST"
+        });
+        logDryStep("firefox", "Would poll for validation", {
+            interval: `${POLL_INTERVAL_MS / 1000}s`,
+            timeout: `${VALIDATION_TIMEOUT_MS / 60000}min`
+        });
+        logDryStep("firefox", "Would create new version", {
+            target: `${AMO_BASE}/addon/${addonId}/versions/`,
+            method: "POST",
+            sourcesZip: options.sourcesZip ? `${options.sourcesZip} (${formatBytes(sourcesSize)})` : "(none)"
+        });
+        log("firefox", "Dry run complete \u2014 no changes made");
+        return outcome;
+    }
+    const upload = await uploadAndAwaitProcessing(options, jwtIssuer, jwtSecret);
+    outcome.submissionId = upload.uuid;
+    log("firefox", "Creating new version");
+    const version = await createVersion({
+        addonId,
+        sourcesZip: options.sourcesZip,
+        uploadUuid: upload.uuid,
+        jwtIssuer,
+        jwtSecret
+    });
+    outcome.submissionId = String(version.id);
+    const { errors, warnings, notices } = upload.validation;
+    log("firefox", `Validation: ${errors} error(s), ${warnings} warning(s), ${notices} notice(s)`);
+    if (!upload.valid) throw new Error("Firefox extension failed validation");
+    return outcome;
+}
+function getFirefoxVersion(params) {
+    const normalized = normalizeAddonId(params.addonId);
+    return fetchJson(`${AMO_BASE}/addon/${normalized}/versions/${params.versionId}/`, {
+        headers: authHeaders(params.jwtIssuer, params.jwtSecret)
+    });
+}
+async function uploadAndAwaitProcessing(options, jwtIssuer, jwtSecret) {
+    const size = await getFileSize(options.zip);
+    log("firefox", `Uploading ZIP file (${formatBytes(size)})`);
+    let result = await createUpload(options.zip, options.channel, jwtIssuer, jwtSecret);
+    log("firefox", "Waiting for validation");
+    const deadline = Date.now() + VALIDATION_TIMEOUT_MS;
+    while(!result.processed){
+        if (Date.now() > deadline) throw new Error(`Firefox validation timed out after ${VALIDATION_TIMEOUT_MS}ms`);
+        await delay(POLL_INTERVAL_MS);
+        result = await getUpload(result.uuid, jwtIssuer, jwtSecret);
+    }
+    return result;
+}
+function normalizeAddonId(id) {
+    if (id.startsWith("{") && id.endsWith("}")) return id.slice(1, -1);
+    return id;
+}
+async function verifyFirefoxCredentials(params) {
+    try {
+        const jwt = signJwt(params.jwtIssuer, params.jwtSecret, 60);
+        await fetchJson(AMO_PROFILE_URL, {
+            headers: {
+                Authorization: `JWT ${jwt}`
+            }
+        });
+    } catch (err) {
+        return {
+            ok: false,
+            message: `AMO API credential check failed. Verify your JWT Issuer and Secret are correct.\n${err instanceof Error ? err.message : err}`
+        };
+    }
+    if (params.addonId) {
+        const normalizedId = normalizeAddonId(params.addonId);
+        try {
+            const addon = await getAddon(normalizedId, params.jwtIssuer, params.jwtSecret);
+            const name = addon.name ?? params.addonId;
+            const displayName = "object" == typeof name && null !== name ? name.en_US ?? params.addonId : String(name);
+            return {
+                ok: true,
+                message: `API credentials and add-on ownership verified. You have access to "${displayName}".`,
+                addonName: displayName
+            };
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("404")) return {
+                ok: false,
+                message: "Add-on GUID not found. Verify the GUID is correct in your add-on's Developer Hub page."
+            };
+            if (msg.includes("403") || msg.includes("401")) return {
+                ok: false,
+                message: "You don't have permission to access this add-on. Verify you're using credentials for the correct account."
+            };
+            return {
+                ok: false,
+                message: `Failed to verify add-on ownership: ${msg}`
+            };
+        }
+    }
+    return {
+        ok: true,
+        message: "API credentials verified. Provide an addon GUID to also verify add-on ownership."
+    };
+}
+const EDGE_API_BASE = "https://api.addons.microsoftedge.microsoft.com/v1/products";
+const edge_POLL_INTERVAL_MS = 5000;
+const edge_VALIDATION_TIMEOUT_MS = 600000;
+function edgeStoreUrl(productId) {
+    return `https://microsoftedge.microsoft.com/addons/detail/${productId}`;
+}
+function partnerHeaders(clientId, apiKey) {
+    return {
+        Authorization: `ApiKey ${apiKey}`,
+        "X-ClientID": clientId
+    };
+}
+async function uploadDraft(productId, zipPath, clientId, apiKey) {
+    const body = await promises_default.readFile(zipPath);
+    const res = await fetchRaw(`${EDGE_API_BASE}/${productId}/submissions/draft/package`, {
+        method: "POST",
+        body,
+        headers: {
+            ...partnerHeaders(clientId, apiKey),
+            "Content-Type": "application/zip"
+        }
+    });
+    const operationId = res.headers.get("Location");
+    if (!operationId) throw new Error("Edge API did not return an operation ID in the Location header.");
+    return operationId;
+}
+function getDraftOperation(productId, operationId, clientId, apiKey) {
+    return fetchJson(`${EDGE_API_BASE}/${productId}/submissions/draft/package/operations/${operationId}`, {
+        headers: partnerHeaders(clientId, apiKey)
+    });
+}
+async function submitForReview(productId, clientId, apiKey) {
+    const res = await fetchRaw(`${EDGE_API_BASE}/${productId}/submissions`, {
+        method: "POST",
+        body: JSON.stringify({}),
+        headers: {
+            ...partnerHeaders(clientId, apiKey),
+            "Content-Type": "application/json"
+        }
+    });
+    const location = res.headers.get("Location");
+    if (!location) return;
+    const segments = location.split("/").filter(Boolean);
+    return segments[segments.length - 1];
+}
+async function publishEdge(options, dryRun) {
+    await assertFilePresent(options.zip);
+    const zipSize = await getFileSize(options.zip);
+    const outcome = {
+        storeUrl: edgeStoreUrl(options.productId),
+        submissionId: options.productId
+    };
+    if (dryRun) {
+        logDryStep("edge", "Credentials assumed valid (no preflight endpoint)", {
+            productId: options.productId,
+            clientId: options.clientId
+        });
+        logDryStep("edge", "Would upload draft ZIP", {
+            file: options.zip,
+            size: formatBytes(zipSize),
+            target: `${EDGE_API_BASE}/${options.productId}/submissions/draft/package`,
+            method: "POST"
+        });
+        logDryStep("edge", "Would poll draft operation", {
+            interval: `${edge_POLL_INTERVAL_MS / 1000}s`,
+            timeout: `${edge_VALIDATION_TIMEOUT_MS / 60000}min`
+        });
+        options.skipSubmitReview ? logDryStep("edge", "Would skip submit (skipSubmitReview=true)") : logDryStep("edge", "Would submit for review", {
+            target: `${EDGE_API_BASE}/${options.productId}/submissions`,
+            method: "POST"
+        });
+        log("edge", "Dry run complete \u2014 no changes made");
+        return outcome;
+    }
+    const uploadOperationId = await edge_uploadAndAwaitProcessing(options);
+    outcome.submissionId = uploadOperationId;
+    if (options.skipSubmitReview) {
+        log("edge", "Skipping publish step (skipSubmitReview=true)");
+        return outcome;
+    }
+    log("edge", "Submitting for review");
+    const publishOperationId = await submitForReview(options.productId, options.clientId, options.apiKey);
+    if (publishOperationId) outcome.submissionId = publishOperationId;
+    return outcome;
+}
+function getEdgePublishOperation(params) {
+    return fetchJson(`${EDGE_API_BASE}/${params.productId}/submissions/operations/${params.operationId}`, {
+        headers: partnerHeaders(params.clientId, params.apiKey)
+    });
+}
+async function verifyEdgeCredentials(params) {
+    const headers = partnerHeaders(params.clientId, params.apiKey);
+    if (!params.productId) {
+        const res = await fetch(EDGE_API_BASE, {
+            headers
+        });
+        if (401 === res.status || 403 === res.status) return {
+            ok: false,
+            message: "Invalid credentials. Verify your Client ID and API Key are correct."
+        };
+        if (!res.ok) return {
+            ok: false,
+            message: `Edge Partner API check failed (HTTP ${res.status}).`
+        };
+        return {
+            ok: true,
+            message: "Credentials verified. Provide a Product ID to also verify extension ownership."
+        };
+    }
+    const res = await fetch(`${EDGE_API_BASE}/${encodeURIComponent(params.productId)}/submissions/draft`, {
+        headers
+    });
+    if (401 === res.status) return {
+        ok: false,
+        message: "Unauthorized. Verify your API credentials are correct."
+    };
+    if (403 === res.status) {
+        const body = await res.text().catch(()=>"");
+        if (/product not found|not found/i.test(body)) return {
+            ok: false,
+            message: "Product ID not found or not owned by this account. Verify the GUID matches your Partner Center extension."
+        };
+        return {
+            ok: false,
+            message: "Invalid credentials. Verify your Client ID and API Key are correct."
+        };
+    }
+    if (200 === res.status) return {
+        ok: true,
+        message: "Credentials and Product ID verified. Draft submission exists."
+    };
+    if (404 === res.status) return {
+        ok: true,
+        message: "Credentials and Product ID verified. Ready to submit."
+    };
+    return {
+        ok: false,
+        message: `Edge Partner API check failed (HTTP ${res.status}).`
+    };
+}
+async function edge_uploadAndAwaitProcessing(options) {
+    const size = await getFileSize(options.zip);
+    log("edge", `Uploading ZIP file (${formatBytes(size)})`);
+    const operationId = await uploadDraft(options.productId, options.zip, options.clientId, options.apiKey);
+    log("edge", "Waiting for validation");
+    const deadline = Date.now() + edge_VALIDATION_TIMEOUT_MS;
+    let operation;
+    do {
+        if (Date.now() > deadline) throw new Error(`Edge validation timed out after ${edge_VALIDATION_TIMEOUT_MS}ms`);
+        await delay(edge_POLL_INTERVAL_MS);
+        operation = await getDraftOperation(options.productId, operationId, options.clientId, options.apiKey);
+    }while ("InProgress" === operation.status);
+    if ("Failed" === operation.status) throw new Error(`Edge validation failed: ${JSON.stringify(operation, null, 2)}`);
+    log("edge", "Extension is valid");
+    return operationId;
+}
+async function deploy(config) {
+    const validated = validateConfig(config);
+    const { dryRun } = validated;
+    const jobs = [];
+    if (validated.chrome) {
+        const opts = validated.chrome;
+        jobs.push({
+            key: "chrome",
+            run: ()=>publishChrome(opts, dryRun)
+        });
+    }
+    if (validated.firefox) {
+        const opts = validated.firefox;
+        jobs.push({
+            key: "firefox",
+            run: ()=>publishFirefox(opts, dryRun)
+        });
+    }
+    if (validated.edge) {
+        const opts = validated.edge;
+        jobs.push({
+            key: "edge",
+            run: ()=>publishEdge(opts, dryRun)
+        });
+    }
+    if (0 === jobs.length) throw new Error("No stores configured. Provide at least one store to deploy to.\n\nEach store is activated by providing its ZIP path:\n  Chrome:  --chrome-zip <path>   or  CHROME_ZIP=<path>\n  Firefox: --firefox-zip <path>  or  FIREFOX_ZIP=<path>\n  Edge:    --edge-zip <path>     or  EDGE_ZIP=<path>\n\nRun extension-deploy --help for all options, or create a .env.submit file.");
+    if (dryRun) console.log("\n[deploy] Dry run enabled \u2014 will verify auth without uploading\n");
+    else console.log("\n[deploy] Deploying extension\n");
+    const settled = await Promise.allSettled(jobs.map(async ({ key, run })=>{
+        const start = Date.now();
+        try {
+            const outcome = await run();
+            return {
+                store: key,
+                success: true,
+                status: dryRun ? "dry_run" : "submitted",
+                duration: Date.now() - start,
+                storeUrl: outcome.storeUrl,
+                submissionId: outcome.submissionId
+            };
+        } catch (err) {
+            return {
+                store: key,
+                success: false,
+                status: "failed",
+                error: err instanceof Error ? err.message : String(err),
+                duration: Date.now() - start
+            };
+        }
+    }));
+    const stores = settled.map((s, i)=>"fulfilled" === s.status ? s.value : {
+            store: jobs[i].key,
+            success: false,
+            status: "failed",
+            error: s.reason instanceof Error ? s.reason.message : String(s.reason),
+            duration: 0
+        });
+    const success = stores.every((s)=>s.success);
+    console.log("\n--- Deploy Summary ---");
+    for (const s of stores){
+        const icon = s.success ? "OK" : "FAIL";
+        console.log(`  ${icon} ${s.store} (${s.status}, ${s.duration}ms)`);
+        if (s.error) console.error(`      ${s.error}`);
+    }
+    console.log("");
+    return {
+        dryRun,
+        stores,
+        success
+    };
+}
+const DEFAULT_POLL_INTERVAL_MS = 60000;
+const DEFAULT_TIMEOUT_MS = 3600000;
+function watch_now() {
+    return new Date().toISOString();
+}
+function isTerminal(status) {
+    return "published" === status || "rejected" === status || "failed" === status;
+}
+async function getChromeSubmissionEvent(input) {
+    try {
+        const item = await getChromeItem(input);
+        const uploadState = item.uploadState;
+        let status = "unknown";
+        let message;
+        if ("SUCCESS" === uploadState) {
+            status = "in_review";
+            message = "Upload accepted by the Chrome Web Store. Review state is not exposed via API; check the developer dashboard for final outcome.";
+        } else if ("IN_PROGRESS" === uploadState) status = "processing";
+        else if ("FAILURE" === uploadState) {
+            var _item_itemError;
+            status = "failed";
+            message = (null == (_item_itemError = item.itemError) ? void 0 : _item_itemError.map((e)=>e.error_detail).join("; ")) ?? "Upload reported FAILURE by Chrome Web Store.";
+        }
+        return {
+            store: "chrome",
+            status,
+            nativeStatus: uploadState,
+            message,
+            polledAt: watch_now(),
+            submissionId: input.extensionId,
+            storeUrl: chromeStoreUrl(input.extensionId)
+        };
+    } catch (err) {
+        return {
+            store: "chrome",
+            status: "failed",
+            message: err instanceof Error ? err.message : String(err),
+            polledAt: watch_now(),
+            submissionId: input.extensionId,
+            storeUrl: chromeStoreUrl(input.extensionId)
+        };
+    }
+}
+function watchChromeSubmission(input, options = {}) {
+    return runWatchLoop("chrome", ()=>getChromeSubmissionEvent(input), options);
+}
+function mapEdgeStatus(native) {
+    switch(native){
+        case "Succeeded":
+            return "published";
+        case "Failed":
+            return "failed";
+        case "InProgress":
+        default:
+            return "in_review";
+    }
+}
+async function getEdgeSubmissionEvent(input) {
+    try {
+        const op = await getEdgePublishOperation({
+            productId: input.productId,
+            operationId: input.operationId,
+            clientId: input.clientId,
+            apiKey: input.apiKey
+        });
+        return {
+            store: "edge",
+            status: mapEdgeStatus(op.status),
+            nativeStatus: op.status,
+            message: op.message ?? void 0,
+            polledAt: watch_now(),
+            submissionId: input.operationId,
+            storeUrl: edgeStoreUrl(input.productId)
+        };
+    } catch (err) {
+        return {
+            store: "edge",
+            status: "failed",
+            message: err instanceof Error ? err.message : String(err),
+            polledAt: watch_now(),
+            submissionId: input.operationId,
+            storeUrl: edgeStoreUrl(input.productId)
+        };
+    }
+}
+function watchEdgeSubmission(input, options = {}) {
+    return runWatchLoop("edge", ()=>getEdgeSubmissionEvent(input), options);
+}
+function mapFirefoxFileStatus(native) {
+    if (!native) return "unknown";
+    if ("public" === native) return "published";
+    if ("unreviewed" === native) return "in_review";
+    if ("disabled" === native) return "rejected";
+    return "unknown";
+}
+async function getFirefoxSubmissionEvent(input) {
+    try {
+        const version = await getFirefoxVersion({
+            addonId: input.extensionId,
+            versionId: input.versionId,
+            jwtIssuer: input.jwtIssuer,
+            jwtSecret: input.jwtSecret
+        });
+        const fileStatus = version.file.status;
+        return {
+            store: "firefox",
+            status: mapFirefoxFileStatus(fileStatus),
+            nativeStatus: fileStatus,
+            polledAt: watch_now(),
+            submissionId: String(version.id),
+            storeUrl: firefoxStoreUrl(input.extensionId)
+        };
+    } catch (err) {
+        return {
+            store: "firefox",
+            status: "failed",
+            message: err instanceof Error ? err.message : String(err),
+            polledAt: watch_now(),
+            submissionId: String(input.versionId),
+            storeUrl: firefoxStoreUrl(input.extensionId)
+        };
+    }
+}
+function watchFirefoxSubmission(input, options = {}) {
+    return runWatchLoop("firefox", ()=>getFirefoxSubmissionEvent(input), options);
+}
+async function runWatchLoop(_store, probe, options) {
+    const pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const deadline = Date.now() + timeout;
+    let lastEvent;
+    while(true){
+        var _options_onEvent;
+        lastEvent = await probe();
+        null == (_options_onEvent = options.onEvent) || _options_onEvent.call(options, lastEvent);
+        if (isTerminal(lastEvent.status)) return lastEvent;
+        if (Date.now() >= deadline) return lastEvent;
+        await delay(pollInterval);
+    }
+}
+export { chromeOptionsSchema, deploy, deployConfigSchema, edgeOptionsSchema, firefoxOptionsSchema, getChromeSubmissionEvent, getEdgeSubmissionEvent, getFirefoxSubmissionEvent, resolveConfig, validateConfig, verifyChromeCredentials, verifyEdgeCredentials, verifyFirefoxCredentials, watchChromeSubmission, watchEdgeSubmission, watchFirefoxSubmission };