@sitepong/fastnode 0.1.0 → 0.1.2

package/dist/actions/index.cjs

@@ -178,8 +178,8 @@ async function revokeExpiredCertificates(options) {
   return count;
 }
 async function importToKeychain(certData, keychainPath, keychainPassword) {
-  const { tmpdir: tmpdir7 } = await import('os');
-  const tempCertPath = path.join(tmpdir7(), `fastnode-cert-${Date.now()}.cer`);
+  const { tmpdir: tmpdir8 } = await import('os');
+  const tempCertPath = path.join(tmpdir8(), `fastnode-cert-${Date.now()}.cer`);
   await promises.writeFile(tempCertPath, certData);
   try {
     const args = [
@@ -1611,14 +1611,14 @@ var init_building = __esm({
       name: "clean_build_artifacts",
       description: "Remove build artifacts (IPA, dSYM, etc.)",
       async run(params, ctx) {
-        const { rm: rm2 } = await import('fs/promises');
+        const { rm: rm4 } = await import('fs/promises');
         const paths = [
           ctx.get("IPA_OUTPUT_PATH"),
           ctx.get("PKG_OUTPUT_PATH"),
           ctx.get("DSYM_OUTPUT_PATH")
         ].filter(Boolean);
         for (const p of paths) {
-          await rm2(p, { force: true }).catch(() => {
+          await rm4(p, { force: true }).catch(() => {
           });
         }
         return { cleaned: paths };
@@ -2265,23 +2265,13 @@ var init_request = __esm({
     };
   }
 });
-
-// src/pilot/index.ts
-var pilot_exports = {};
-__export(pilot_exports, {
-  distributeToGroups: () => distributeToGroups,
-  expireBuild: () => expireBuild,
-  setChangelog: () => setChangelog,
-  uploadToTestFlight: () => uploadToTestFlight,
-  waitForProcessing: () => waitForProcessing
-});
-async function uploadToTestFlight(options) {
+async function uploadWithAltool(options) {
   if (!fs.existsSync(options.ipaPath)) {
     throw new Error(`File not found: ${options.ipaPath}`);
   }
   const platform = options.platform ?? "ios";
   const timeout = options.timeout ?? 18e5;
-  const keyDir = await promises.mkdtemp(path.join(os.tmpdir(), "fastnode-key-"));
+  const keyDir = await promises.mkdtemp(path.join(os.tmpdir(), "fastnode-altool-"));
   const keyPath = path.join(keyDir, `AuthKey_${options.apiKeyId}.p8`);
   await promises.writeFile(keyPath, options.apiPrivateKey);
   return new Promise((resolve3) => {
@@ -2305,24 +2295,228 @@ async function uploadToTestFlight(options) {
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
     }, timeout);
-    child.stdout.on("data", (data) => {
+    const onData = (data) => {
       const chunk = data.toString();
       output += chunk;
       options.onOutput?.(chunk);
+    };
+    child.stdout.on("data", onData);
+    child.stderr.on("data", onData);
+    child.on("close", async (code) => {
+      clearTimeout(timer);
+      await promises.unlink(keyPath).catch(() => {
+      });
+      await promises.rm(keyDir, { recursive: true, force: true }).catch(() => {
+      });
+      resolve3({ success: code === 0, output, backend: "altool" });
     });
-    child.stderr.on("data", (data) => {
+  });
+}
+var init_upload_altool = __esm({
+  "src/pilot/upload-altool.ts"() {
+  }
+});
+async function resolveTransporter() {
+  const override = process.env.ITMSTRANSPORTER_BIN;
+  if (override) {
+    if (!fs.existsSync(override)) {
+      throw new Error(
+        `ITMSTRANSPORTER_BIN is set to "${override}" but that path does not exist.`
+      );
+    }
+    return override;
+  }
+  const candidates = process.platform === "darwin" ? [
+    // Xcode 15+: Transporter.app bundled with Xcode
+    "/Applications/Xcode.app/Contents/SharedFrameworks/ContentDeliveryServices.framework/Versions/A/itms/bin/iTMSTransporter",
+    // Standalone Transporter.app from the Mac App Store
+    "/Applications/Transporter.app/Contents/itms/bin/iTMSTransporter"
+  ] : [
+    "/usr/local/itms/bin/iTMSTransporter",
+    "/opt/itms/bin/iTMSTransporter",
+    "/usr/local/bin/iTMSTransporter"
+  ];
+  for (const path of candidates) {
+    if (fs.existsSync(path)) return path;
+  }
+  throw new Error(
+    [
+      "iTMSTransporter not found.",
+      "",
+      "Install options:",
+      process.platform === "darwin" ? "  - Install Xcode (includes Transporter)" : "  - Download Apple's standalone iTMSTransporter package for Linux",
+      "  - Or set ITMSTRANSPORTER_BIN to the absolute path of the binary",
+      "",
+      `Searched: ${candidates.join(", ")}`
+    ].join("\n")
+  );
+}
+async function verifyJava() {
+  return new Promise((resolve3, reject) => {
+    const child = child_process.spawn("java", ["-version"], { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      reject(
+        new Error(
+          `java not found on PATH (${err.message}). Install Java 17 LTS and ensure it is on PATH.`
+        )
+      );
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`java -version exited ${code}: ${stderr}`));
+        return;
+      }
+      const match = stderr.match(/version "([^"]+)"/);
+      resolve3({ version: match?.[1] ?? "unknown" });
+    });
+  });
+}
+var init_transporter_install = __esm({
+  "src/pilot/transporter-install.ts"() {
+  }
+});
+async function uploadWithTransporter(options) {
+  if (!fs.existsSync(options.ipaPath)) {
+    throw new Error(`File not found: ${options.ipaPath}`);
+  }
+  await verifyJava();
+  const transporterBin = await resolveTransporter();
+  const platform = options.platform ?? "ios";
+  const timeout = options.timeout ?? 18e5;
+  const keyDir = await promises.mkdtemp(path.join(os.tmpdir(), "fastnode-itms-"));
+  const keyPath = path.join(keyDir, `AuthKey_${options.apiKeyId}.p8`);
+  await promises.writeFile(keyPath, options.apiPrivateKey);
+  return new Promise((resolve3) => {
+    const args = [
+      "-m",
+      "upload",
+      "-assetFile",
+      options.ipaPath,
+      "-apiKey",
+      options.apiKeyId,
+      "-apiIssuer",
+      options.apiIssuerId,
+      // WONoPause prevents the JVM from waiting on stdin in non-TTY
+      // environments (CI, LaunchAgent) where it would hang forever.
+      "-WONoPause",
+      "true"
+    ];
+    if (platform !== "ios") {
+      args.push("-bundleType", platform);
+    }
+    const child = child_process.spawn(transporterBin, args, {
+      env: {
+        ...process.env,
+        API_PRIVATE_KEYS_DIR: keyDir
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeout);
+    const onData = (data) => {
       const chunk = data.toString();
       output += chunk;
       options.onOutput?.(chunk);
-    });
+    };
+    child.stdout.on("data", onData);
+    child.stderr.on("data", onData);
     child.on("close", async (code) => {
       clearTimeout(timer);
-      await promises.unlink(keyPath).catch(() => {
+      await promises.rm(keyDir, { recursive: true, force: true }).catch(() => {
+      });
+      resolve3({ success: code === 0, output, backend: "transporter" });
+    });
+    child.on("error", async (err) => {
+      clearTimeout(timer);
+      await promises.rm(keyDir, { recursive: true, force: true }).catch(() => {
+      });
+      resolve3({
+        success: false,
+        output: output + `
+Process error: ${err.message}`,
+        backend: "transporter"
       });
-      resolve3({ success: code === 0, output });
     });
   });
 }
+var init_upload_transporter = __esm({
+  "src/pilot/upload-transporter.ts"() {
+    init_transporter_install();
+  }
+});
+
+// src/pilot/classify.ts
+function classifyUploadError(output) {
+  for (const { pattern, kind } of RULES) {
+    if (pattern.test(output)) return kind;
+  }
+  return null;
+}
+function isTransientUploadError(output) {
+  return classifyUploadError(output) !== null;
+}
+var RULES;
+var init_classify = __esm({
+  "src/pilot/classify.ts"() {
+    RULES = [
+      // Apple's finalize-upload call returning 5xx — the most common transient
+      // failure we see in practice. Example:
+      //   "CHANGE UPLOAD STATE TO COMPLETE (UPLOADING ASSET DESCRIPTION):
+      //    received status code 500; internal server error."
+      { pattern: /CHANGE UPLOAD STATE TO COMPLETE/i, kind: "finalize_failed" },
+      // Generic 5xx from ASC backend services
+      { pattern: /status code 5\d\d/i, kind: "apple_5xx" },
+      { pattern: /internal server error/i, kind: "apple_5xx" },
+      { pattern: /Service Unavailable/i, kind: "apple_5xx" },
+      { pattern: /Bad Gateway/i, kind: "apple_5xx" },
+      // Network-level interruptions during the upload body transfer
+      { pattern: /Connection reset/i, kind: "connection_reset" },
+      { pattern: /SocketException/i, kind: "connection_reset" },
+      { pattern: /Broken pipe/i, kind: "connection_reset" },
+      // Timeouts — distinct from resets because the other side may have
+      // actually processed the request, so dedupe logic may matter.
+      { pattern: /Read timed out/i, kind: "network_timeout" },
+      { pattern: /SocketTimeoutException/i, kind: "network_timeout" },
+      { pattern: /Operation timed out/i, kind: "network_timeout" },
+      // JVM-internal errors from iTMSTransporter (OOM, thread interruption, etc.)
+      { pattern: /java\.lang\.OutOfMemoryError/i, kind: "transporter_jvm_error" },
+      { pattern: /EOFException/i, kind: "transporter_jvm_error" }
+    ];
+  }
+});
+
+// src/pilot/index.ts
+var pilot_exports = {};
+__export(pilot_exports, {
+  classifyUploadError: () => classifyUploadError,
+  distributeToGroups: () => distributeToGroups,
+  expireBuild: () => expireBuild,
+  isTransientUploadError: () => isTransientUploadError,
+  resolveTransporter: () => resolveTransporter,
+  setChangelog: () => setChangelog,
+  uploadToTestFlight: () => uploadToTestFlight,
+  uploadWithAltool: () => uploadWithAltool,
+  uploadWithTransporter: () => uploadWithTransporter,
+  verifyJava: () => verifyJava,
+  waitForProcessing: () => waitForProcessing
+});
+async function uploadToTestFlight(options) {
+  const backend = selectBackend(options.backend ?? "auto");
+  if (backend === "altool") {
+    return uploadWithAltool(options);
+  }
+  return uploadWithTransporter(options);
+}
+function selectBackend(pref) {
+  if (pref !== "auto") return pref;
+  return process.platform === "darwin" ? "altool" : "transporter";
+}
 async function waitForProcessing(client, params) {
   const timeout = params.timeout ?? 18e5;
   const pollInterval = params.pollInterval ?? 3e4;
@@ -2443,6 +2637,12 @@ function sleep2(ms) {
 var init_pilot = __esm({
   "src/pilot/index.ts"() {
     init_request();
+    init_upload_altool();
+    init_upload_transporter();
+    init_upload_altool();
+    init_upload_transporter();
+    init_classify();
+    init_transporter_install();
   }
 });
 async function loadMetadata(metadataPath) {
@@ -2530,9 +2730,9 @@ var init_metadata = __esm({
 // src/xcode/upload.ts
 var upload_exports = {};
 __export(upload_exports, {
-  uploadWithAltool: () => uploadWithAltool
+  uploadWithAltool: () => uploadWithAltool2
 });
-async function uploadWithAltool(options) {
+async function uploadWithAltool2(options) {
   requireMacOS("altool upload");
   let keyDir;
   if (options.apiPrivateKey && !options.apiKeyPath) {
@@ -2641,8 +2841,8 @@ async function uploadToAppStore(options) {
   if (!options.skipBinaryUpload) {
     const binaryPath = options.ipaPath ?? options.pkgPath;
     if (binaryPath && options.apiKeyId && options.apiIssuerId) {
-      const { uploadWithAltool: uploadWithAltool2 } = await Promise.resolve().then(() => (init_upload(), upload_exports));
-      await uploadWithAltool2({
+      const { uploadWithAltool: uploadWithAltool3 } = await Promise.resolve().then(() => (init_upload(), upload_exports));
+      await uploadWithAltool3({
         filePath: binaryPath,
         apiKeyId: options.apiKeyId,
         apiIssuerId: options.apiIssuerId,
@@ -3428,8 +3628,8 @@ async function captureScreenshots(options) {
   const outputDir = options.outputDirectory ?? path.join(process.cwd(), "screenshots");
   const retries = options.numberOfRetries ?? 1;
   if (options.clearPreviousScreenshots && fs.existsSync(outputDir)) {
-    const { rm: rm2 } = await import('fs/promises');
-    await rm2(outputDir, { recursive: true, force: true });
+    const { rm: rm4 } = await import('fs/promises');
+    await rm4(outputDir, { recursive: true, force: true });
   }
   fs.mkdirSync(outputDir, { recursive: true });
   const screenshots = {};