@qoder-ai/qoder-agent-sdk 1.0.20 → 1.0.22

package/scripts/postinstall.cjs

@@ -30,7 +30,6 @@ const CN_DEV_DOWNLOAD_BASE_URL = 'https://static.qoder.com.cn/qoder-cli-cn/dev/r
 const PACKAGE_JSON = require('../package.json');
 const LOG_PREFIX = `[${PACKAGE_JSON.name ?? '@qoder-ai/qoder-agent-sdk'}]`;
 const WORKER_RUNTIME_ENTRY_NAMES = ['qoder-worker-runtime.obf.mjs', 'qoder-worker-runtime.mjs'];
-const REQUIRED_WORKER_RUNTIME_ASSETS = [path.join('vendor', 'ripgrep', 'x64-win32', 'rg.exe')];
 
 function isTruthy(value) {
   return value === '1' || value === 'true';
@@ -143,6 +142,7 @@ function normalizePlatformOverride(value) {
     'linux-x64',
     'linux-x64-baseline',
     'linux-x64-musl',
+    'openharmony-arm64',
     'windows-arm64',
     'windows-x64',
   ]);
@@ -182,6 +182,15 @@ function getPlatformTarget() {
     }
   }
 
+  // HarmonyOS reports process.platform === 'openharmony'. Only aarch64 is
+  // produced; the artifact is qodercli-openharmony-arm64.tar.gz.
+  if (process.platform === 'openharmony') {
+    if (process.arch !== 'arm64') {
+      throw new Error(`Unsupported OpenHarmony architecture: ${process.arch}`);
+    }
+    return 'openharmony-arm64';
+  }
+
   throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
 }
 
@@ -199,8 +208,36 @@ function getDownloadUrl() {
   return `${baseUrl}/${getArtifactName()}`;
 }
 
-function getWorkerRuntimeArtifactName(site = getCliSite()) {
-  return `${getCliArtifactPrefix(site)}-worker-runtime-universal.tgz`;
+function getWorkerRuntimeTarget(target = getPlatformTarget()) {
+  const [platform, arch] = target.split('-');
+  if (platform === 'darwin') return `darwin-${arch}`;
+  if (platform === 'linux') return `linux-${arch}`;
+  if (platform === 'windows') return `win32-${arch}`;
+  throw new Error(
+    `Worker runtime platform artifacts do not support ${target}. Supported: darwin-arm64, darwin-x64, linux-arm64, linux-x64, windows-arm64, windows-x64`,
+  );
+}
+
+function getWorkerRuntimeArtifactName(site = getCliSite(), target = getPlatformTarget()) {
+  const workerTarget = getWorkerRuntimeTarget(target);
+  return `${getCliArtifactPrefix(site)}-worker-runtime-${workerTarget}.tgz`;
+}
+
+function getWorkerRuntimeArtifactNameTemplate(site = getCliSite()) {
+  return `${getCliArtifactPrefix(site)}-worker-runtime-{target}.tgz`;
+}
+
+function getWorkerRuntimeRequiredAssets(target = getPlatformTarget()) {
+  const workerTarget = getWorkerRuntimeTarget(target);
+  const [platform, arch] = workerTarget.split('-');
+  return [
+    path.join(
+      'vendor',
+      'ripgrep',
+      `${arch}-${platform}`,
+      platform === 'win32' ? 'rg.exe' : 'rg',
+    ),
+  ];
 }
 
 function hasWorkerRuntimeDownloadSiteOverride() {
@@ -221,6 +258,14 @@ function getManifestWorkerRuntimeDownloadUrl(manifest = readRuntimeManifest()) {
   return url ?? null;
 }
 
+function getManifestWorkerRuntimeDownloadUrlTemplate(manifest = readRuntimeManifest()) {
+  const workerRuntime = getManifestWorkerRuntime(manifest);
+  if (!workerRuntime || workerRuntime.packaged === true) return null;
+  return typeof workerRuntime.urlTemplate === 'string' && workerRuntime.urlTemplate.length > 0
+    ? workerRuntime.urlTemplate
+    : null;
+}
+
 function getManifestWorkerRuntimeSha256(manifest = readRuntimeManifest()) {
   const workerRuntime = getManifestWorkerRuntime(manifest);
   if (!workerRuntime || workerRuntime.packaged === true) return null;
@@ -236,30 +281,39 @@ function getManifestWorkerRuntimeSha256(manifest = readRuntimeManifest()) {
   return checksum ? checksum.trim().toLowerCase() : null;
 }
 
+function getWorkerRuntimeDownloadUrlTemplate() {
+  const version = getCliVersion();
+  const baseUrl = normalizeDownloadBaseUrl(getWorkerRuntimeDownloadBaseUrl(version), version);
+  return `${baseUrl}/${getWorkerRuntimeArtifactNameTemplate()}`;
+}
+
+function getWorkerRuntimeDefaultDownloadUrl() {
+  return getWorkerRuntimeDownloadUrlTemplate().replace(
+    '{target}',
+    getWorkerRuntimeTarget(),
+  );
+}
+
 function getWorkerRuntimeDownloadUrl() {
   if (process.env.QODER_WORKER_RUNTIME_URL) {
     return process.env.QODER_WORKER_RUNTIME_URL;
   }
 
-  const manifestUrl = hasWorkerRuntimeDownloadSiteOverride()
-    ? null
-    : getManifestWorkerRuntimeDownloadUrl();
-  if (manifestUrl) {
-    return manifestUrl;
+  if (!hasWorkerRuntimeDownloadSiteOverride()) {
+    const template = getManifestWorkerRuntimeDownloadUrlTemplate();
+    if (template) {
+      return template.replace('{target}', getWorkerRuntimeTarget());
+    }
+    const manifestUrl = getManifestWorkerRuntimeDownloadUrl();
+    if (manifestUrl) return manifestUrl;
   }
 
-  const version = getCliVersion();
-  const baseUrl = normalizeDownloadBaseUrl(getWorkerRuntimeDownloadBaseUrl(version), version);
-  return `${baseUrl}/${getWorkerRuntimeArtifactName()}`;
+  return getWorkerRuntimeDefaultDownloadUrl();
 }
 
 function getWorkerRuntimeExpectedSha256(url = getWorkerRuntimeDownloadUrl()) {
   const manifestUrl = getManifestWorkerRuntimeDownloadUrl();
-  if (manifestUrl && manifestUrl === url) {
-    return getManifestWorkerRuntimeSha256();
-  }
-
-  return null;
+  return manifestUrl === url ? getManifestWorkerRuntimeSha256() : null;
 }
 
 function getBundledDir() {
@@ -365,6 +419,15 @@ function isPackagedWorkerRuntimeCompatibleWithSite(site = getCliSite()) {
     runtimeInfo.build && typeof runtimeInfo.build === 'object' ? runtimeInfo.build : {};
   const actualProductName = buildInfo.productName;
   const actualSite = buildInfo.site;
+  const expectedVersion = getCliVersion();
+
+  if (runtimeInfo.version !== expectedVersion) {
+    return false;
+  }
+
+  if (runtimeInfo.profile !== 'platform' || runtimeInfo.target !== getWorkerRuntimeTarget()) {
+    return false;
+  }
 
   if (
     typeof actualProductName === 'string' &&
@@ -452,8 +515,10 @@ async function downloadFile(url, destPath) {
   console.log(`${LOG_PREFIX} Downloading: ${url}`);
   const response = await requestUrl(url);
   if (response.statusCode !== 200) {
+    const error = new Error(`Download failed: HTTP ${response.statusCode}`);
+    error.statusCode = response.statusCode;
     response.resume();
-    throw new Error(`Download failed: HTTP ${response.statusCode}`);
+    throw error;
   }
 
   await new Promise((resolve, reject) => {
@@ -496,6 +561,7 @@ async function downloadWithRetry(url, destPath, maxRetries = 2) {
       lastError = error;
       console.error(`${LOG_PREFIX} Download failed: ${error.message}`);
       fs.rmSync(destPath, { force: true });
+      if (error.statusCode === 404) break;
     }
   }
   throw lastError;
@@ -699,7 +765,7 @@ function assertWorkerRuntimeComplete(runtimeDir, sourceDescription) {
     throw new Error(`Worker runtime entry missing in ${sourceDescription}: ${runtimePath}`);
   }
 
-  const missingAssets = REQUIRED_WORKER_RUNTIME_ASSETS.filter(
+  const missingAssets = getWorkerRuntimeRequiredAssets().filter(
     (assetPath) => !fs.existsSync(path.join(runtimeDir, assetPath)),
   );
   if (missingAssets.length > 0) {
@@ -715,7 +781,49 @@ function assertWorkerRuntimeComplete(runtimeDir, sourceDescription) {
   return runtimePath;
 }
 
-function installExtractedWorkerRuntime(extractDir, workerDir) {
+function assertWorkerRuntimeIdentity(runtimeDir) {
+  const runtimeInfoPath = path.join(runtimeDir, 'runtime-info.json');
+  if (!fs.existsSync(runtimeInfoPath)) {
+    throw new Error(`Downloaded Worker runtime is missing identity metadata: ${runtimeInfoPath}`);
+  }
+
+  let runtimeInfo;
+  try {
+    runtimeInfo = JSON.parse(fs.readFileSync(runtimeInfoPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Downloaded Worker runtime has invalid identity metadata: ${error.message}`);
+  }
+
+  const expectedTarget = getWorkerRuntimeTarget();
+  const expectedSite = getCliSite();
+  const expectedProductName = getCliArtifactPrefix(expectedSite);
+  const expectedVersion = getCliVersion();
+  const mismatches = [];
+
+  if (runtimeInfo.profile !== 'platform') {
+    mismatches.push(`profile=${String(runtimeInfo.profile)} (expected platform)`);
+  }
+  if (runtimeInfo.target !== expectedTarget) {
+    mismatches.push(`target=${String(runtimeInfo.target)} (expected ${expectedTarget})`);
+  }
+  if (runtimeInfo.version !== expectedVersion) {
+    mismatches.push(`version=${String(runtimeInfo.version)} (expected ${expectedVersion})`);
+  }
+  if (runtimeInfo.build?.site !== expectedSite) {
+    mismatches.push(`site=${String(runtimeInfo.build?.site)} (expected ${expectedSite})`);
+  }
+  if (runtimeInfo.build?.productName !== expectedProductName) {
+    mismatches.push(
+      `productName=${String(runtimeInfo.build?.productName)} (expected ${expectedProductName})`,
+    );
+  }
+
+  if (mismatches.length > 0) {
+    throw new Error(`Downloaded Worker runtime identity mismatch: ${mismatches.join(', ')}`);
+  }
+}
+
+function installExtractedWorkerRuntime(extractDir, workerDir, options = {}) {
   const contentRoot = findWorkerRuntimeRoot(extractDir);
   if (!contentRoot) {
     throw new Error(
@@ -723,6 +831,9 @@ function installExtractedWorkerRuntime(extractDir, workerDir) {
     );
   }
   assertWorkerRuntimeComplete(contentRoot, contentRoot);
+  if (options.validateIdentity === true) {
+    assertWorkerRuntimeIdentity(contentRoot);
+  }
 
   fs.rmSync(workerDir, { recursive: true, force: true });
   copyDirContents(contentRoot, workerDir);
@@ -734,24 +845,36 @@ function installExtractedWorkerRuntime(extractDir, workerDir) {
   return runtimePath;
 }
 
-async function installWorkerRuntimeFromDownload() {
-  const url = getWorkerRuntimeDownloadUrl();
-  const expectedSha256 = getWorkerRuntimeExpectedSha256(url);
+async function downloadAndInstallWorkerRuntime(workerDir, options = {}) {
+  const url = options.urlOverride ?? getWorkerRuntimeDownloadUrl();
+  const expectedSha256 = options.urlOverride ? null : getWorkerRuntimeExpectedSha256(url);
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'qoder-worker-runtime-'));
   const archivePath = path.join(tempDir, path.basename(new URL(url).pathname));
   const extractDir = path.join(tempDir, 'extract');
 
   try {
+    fs.mkdirSync(extractDir, { recursive: true });
     await downloadWithRetry(url, archivePath);
     await verifyChecksum(url, archivePath, expectedSha256);
-    fs.mkdirSync(extractDir, { recursive: true });
     await extractArchive(archivePath, extractDir);
-    return installExtractedWorkerRuntime(extractDir, getPackagedWorkerRuntimeDir());
+    return {
+      runtimePath: installExtractedWorkerRuntime(extractDir, workerDir, {
+        validateIdentity: true,
+      }),
+      url,
+    };
   } finally {
     fs.rmSync(tempDir, { recursive: true, force: true });
   }
 }
 
+async function installWorkerRuntimeFromDownload() {
+  const installed = await downloadAndInstallWorkerRuntime(
+    getPackagedWorkerRuntimeDir(),
+  );
+  return installed.runtimePath;
+}
+
 async function main() {
   if (isTruthy(process.env.QODER_SKIP_DOWNLOAD)) {
     console.log(`${LOG_PREFIX} QODER_SKIP_DOWNLOAD is set, skipping runtime downloads.`);
@@ -839,6 +962,8 @@ if (require.main === module) {
 }
 
 module.exports = {
+  assertWorkerRuntimeIdentity,
+  downloadAndInstallWorkerRuntime,
   downloadWithRetry,
   extractArchive,
   getTarExtractInvocation,
@@ -860,8 +985,13 @@ module.exports = {
   getDefaultRuntimeTransport,
   getWorkerRuntimeExpectedSha256,
   getWorkerRuntimeArtifactName,
+  getWorkerRuntimeArtifactNameTemplate,
   getWorkerRuntimeDownloadBaseUrl,
   getWorkerRuntimeDownloadUrl,
+  getWorkerRuntimeDownloadUrlTemplate,
+  getWorkerRuntimeRequiredAssets,
+  getWorkerRuntimeTarget,
+  getManifestWorkerRuntimeDownloadUrlTemplate,
   hasPackagedWorkerRuntime,
   installExtractedContents,
   installExtractedWorkerRuntime,