@qoder-ai/qoder-agent-sdk 1.0.4 → 1.0.6

package/scripts/postinstall.cjs

@@ -4,8 +4,10 @@
  * provide options.pathToQoderCLIExecutable or QODERCLI_PATH.
  *
  * Environment variables:
- * - QODER_SKIP_DOWNLOAD=1|true: skip download
+ * - QODER_SKIP_DOWNLOAD=1|true: skip postinstall runtime downloads
+ * - QODER_INSTALL_BUNDLED_CLI=1|true: download process fallback even when the packaged default runtime is Worker
  * - QODER_CLI_MIRROR: CDN base URL. Accepts .../qodercli, .../qodercli/dev, or .../releases
+ * - QODER_WORKER_RUNTIME_URL: explicit worker runtime tgz URL override
  * - QODER_CLI_VERSION: override package.json qoderCliVersion
  * - QODER_CLI_SITE: download site. Supports global and cn
  * - QODER_CLI_PLATFORM: override target artifact, e.g. darwin-arm64, linux-x64-musl
@@ -24,6 +26,10 @@ const GLOBAL_PROD_DOWNLOAD_BASE_URL =
   'https://download.qoder.com/qodercli/releases';
 const GLOBAL_DEV_DOWNLOAD_BASE_URL =
   'https://qs-cli-dev.oss-cn-hangzhou.aliyuncs.com/qodercli/dev/releases';
+const CN_PROD_DOWNLOAD_BASE_URL =
+  'https://static.qoder.com.cn/qoder-cli-cn/releases';
+const CN_DEV_DOWNLOAD_BASE_URL =
+  'https://static.qoder.com.cn/qoder-cli-cn/dev/releases';
 const LOG_PREFIX = '[@qoder-ai/qoder-agent-sdk]';
 
 function isTruthy(value) {
@@ -38,7 +44,9 @@ function getCliVersion() {
     const packageJson = require('../package.json');
     const version = packageJson.qoderCliVersion ?? packageJson.version;
     if (!version) {
-      throw new Error('package.json must define "qoderCliVersion" or "version".');
+      throw new Error(
+        'package.json must define "qoderCliVersion" or "version".',
+      );
     }
     return String(version).replace(/^v/, '');
   } catch (error) {
@@ -83,6 +91,21 @@ function getDownloadBaseUrl(version = getCliVersion()) {
   return GLOBAL_PROD_DOWNLOAD_BASE_URL;
 }
 
+function getWorkerRuntimeDownloadBaseUrl(version = getCliVersion()) {
+  if (process.env.QODER_CLI_MIRROR) {
+    return process.env.QODER_CLI_MIRROR;
+  }
+  const site = getCliSite();
+  if (site === 'cn') {
+    return isDevCliVersion(version)
+      ? CN_DEV_DOWNLOAD_BASE_URL
+      : CN_PROD_DOWNLOAD_BASE_URL;
+  }
+  return isDevCliVersion(version)
+    ? GLOBAL_DEV_DOWNLOAD_BASE_URL
+    : GLOBAL_PROD_DOWNLOAD_BASE_URL;
+}
+
 function normalizeDownloadBaseUrl(baseUrl, version = getCliVersion()) {
   const trimmed = baseUrl.replace(/\/+$/, '');
   if (trimmed.endsWith(`/${version}`)) return trimmed;
@@ -119,9 +142,7 @@ function linuxX64HasAvx2() {
 }
 
 function normalizePlatformOverride(value) {
-  const normalized = value
-    .replace(/_/g, '-')
-    .replace(/-amd64(?=-|$)/, '-x64');
+  const normalized = value.replace(/_/g, '-').replace(/-amd64(?=-|$)/, '-x64');
   const supported = new Set([
     'darwin-arm64',
     'darwin-x64',
@@ -181,10 +202,89 @@ function getArtifactName(target = getPlatformTarget()) {
 
 function getDownloadUrl() {
   const version = getCliVersion();
-  const baseUrl = normalizeDownloadBaseUrl(getDownloadBaseUrl(version), version);
+  const baseUrl = normalizeDownloadBaseUrl(
+    getDownloadBaseUrl(version),
+    version,
+  );
   return `${baseUrl}/${getArtifactName()}`;
 }
 
+function getWorkerRuntimeArtifactName(site = getCliSite()) {
+  return `${getCliArtifactPrefix(site)}-worker-runtime-universal.tgz`;
+}
+
+function hasWorkerRuntimeDownloadSiteOverride() {
+  return Boolean(process.env.QODER_CLI_SITE || process.env.QODER_CLI_MIRROR);
+}
+
+function getManifestWorkerRuntime(manifest = readRuntimeManifest()) {
+  const workerRuntime = manifest?.workerRuntime;
+  return workerRuntime && typeof workerRuntime === 'object'
+    ? workerRuntime
+    : null;
+}
+
+function getManifestWorkerRuntimeDownloadUrl(manifest = readRuntimeManifest()) {
+  const workerRuntime = getManifestWorkerRuntime(manifest);
+  if (!workerRuntime || workerRuntime.packaged === true) return null;
+
+  const candidates = [
+    workerRuntime.url,
+    workerRuntime.artifact?.url,
+    workerRuntime.source?.url,
+  ];
+  const url = candidates.find(
+    (candidate) => typeof candidate === 'string' && candidate.length > 0,
+  );
+  return url ?? null;
+}
+
+function getManifestWorkerRuntimeSha256(manifest = readRuntimeManifest()) {
+  const workerRuntime = getManifestWorkerRuntime(manifest);
+  if (!workerRuntime || workerRuntime.packaged === true) return null;
+
+  const candidates = [
+    workerRuntime.sha256,
+    workerRuntime.artifact?.sha256,
+    workerRuntime.source?.sha256,
+  ];
+  const checksum = candidates.find(
+    (candidate) =>
+      typeof candidate === 'string' &&
+      /^[a-fA-F0-9]{64}$/.test(candidate.trim()),
+  );
+  return checksum ? checksum.trim().toLowerCase() : null;
+}
+
+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;
+  }
+
+  const version = getCliVersion();
+  const baseUrl = normalizeDownloadBaseUrl(
+    getWorkerRuntimeDownloadBaseUrl(version),
+    version,
+  );
+  return `${baseUrl}/${getWorkerRuntimeArtifactName()}`;
+}
+
+function getWorkerRuntimeExpectedSha256(url = getWorkerRuntimeDownloadUrl()) {
+  const manifestUrl = getManifestWorkerRuntimeDownloadUrl();
+  if (manifestUrl && manifestUrl === url) {
+    return getManifestWorkerRuntimeSha256();
+  }
+
+  return null;
+}
+
 function getBundledDir() {
   return path.join(__dirname, '..', 'dist', '_bundled');
 }
@@ -194,6 +294,105 @@ function getBundledCliPath() {
   return path.join(getBundledDir(), cliName);
 }
 
+function getPackagedWorkerRuntimePath() {
+  return path.join(
+    __dirname,
+    '..',
+    'dist',
+    '_worker',
+    'qoder-worker-runtime.obf.mjs',
+  );
+}
+
+function getPackagedWorkerRuntimeInfoPath() {
+  return path.join(path.dirname(getPackagedWorkerRuntimePath()), 'runtime-info.json');
+}
+
+function hasPackagedWorkerRuntime() {
+  return fs.existsSync(getPackagedWorkerRuntimePath());
+}
+
+function readPackagedWorkerRuntimeInfo() {
+  const runtimeInfoPath = getPackagedWorkerRuntimeInfoPath();
+  if (!fs.existsSync(runtimeInfoPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(runtimeInfoPath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPackagedWorkerRuntimeCompatibleWithSite(site = getCliSite()) {
+  if (!hasPackagedWorkerRuntime()) return false;
+  if (process.env.QODER_WORKER_RUNTIME_URL) return false;
+
+  const runtimeInfo = readPackagedWorkerRuntimeInfo();
+  if (!runtimeInfo) return false;
+
+  const expectedProductName = getCliArtifactPrefix(site);
+  const buildInfo =
+    runtimeInfo.build && typeof runtimeInfo.build === 'object'
+      ? runtimeInfo.build
+      : {};
+  const actualProductName = buildInfo.productName;
+  const actualSite = buildInfo.site;
+
+  if (
+    typeof actualProductName === 'string' &&
+    actualProductName.length > 0 &&
+    actualProductName !== expectedProductName
+  ) {
+    return false;
+  }
+
+  if (
+    typeof actualSite === 'string' &&
+    actualSite.length > 0 &&
+    actualSite !== site
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function getRuntimeManifestPath() {
+  return path.join(__dirname, '..', 'dist', 'runtime-manifest.json');
+}
+
+function readRuntimeManifest() {
+  const manifestPath = getRuntimeManifestPath();
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function getDefaultRuntimeTransport() {
+  const manifest = readRuntimeManifest();
+  return manifest?.defaultTransport === 'worker' ? 'worker' : 'process';
+}
+
+function shouldInstallWorkerRuntimeForDefaultWorker() {
+  return (
+    getDefaultRuntimeTransport() === 'worker' &&
+    !isPackagedWorkerRuntimeCompatibleWithSite()
+  );
+}
+
+function shouldSkipBundledCliDownloadForWorkerRuntime() {
+  if (getDefaultRuntimeTransport() !== 'worker') return false;
+  return !isTruthy(process.env.QODER_INSTALL_BUNDLED_CLI);
+}
+
 function requestUrl(url, redirectCount = 0) {
   return new Promise((resolve, reject) => {
     if (redirectCount > 5) {
@@ -241,7 +440,10 @@ async function downloadFile(url, destPath) {
   }
 
   await new Promise((resolve, reject) => {
-    const totalSize = Number.parseInt(response.headers['content-length'] || '0', 10);
+    const totalSize = Number.parseInt(
+      response.headers['content-length'] || '0',
+      10,
+    );
     let downloadedSize = 0;
     let lastProgress = 0;
     const file = fs.createWriteStream(destPath);
@@ -299,9 +501,26 @@ function sha256File(filePath) {
   return hash.digest('hex');
 }
 
-async function verifyChecksum(archiveUrl, archivePath) {
+async function verifyChecksum(archiveUrl, archivePath, expectedSha256) {
   if (isTruthy(process.env.QODER_SKIP_CHECKSUM)) {
-    console.log(`${LOG_PREFIX} QODER_SKIP_CHECKSUM is set, skipping checksum verification.`);
+    console.log(
+      `${LOG_PREFIX} QODER_SKIP_CHECKSUM is set, skipping checksum verification.`,
+    );
+    return;
+  }
+
+  if (expectedSha256) {
+    const expected = String(expectedSha256).trim().toLowerCase();
+    if (!/^[a-fA-F0-9]{64}$/.test(expected)) {
+      throw new Error(`Invalid expected sha256: ${expectedSha256}`);
+    }
+    const actual = sha256File(archivePath);
+    if (actual !== expected) {
+      throw new Error(
+        `Checksum verification failed. Expected ${expected}, actual ${actual}`,
+      );
+    }
+    console.log(`${LOG_PREFIX} Checksum verified.`);
     return;
   }
 
@@ -310,14 +529,16 @@ async function verifyChecksum(archiveUrl, archivePath) {
   const expected = parseSha256(fs.readFileSync(checksumPath, 'utf8'));
   const actual = sha256File(archivePath);
   if (actual !== expected) {
-    throw new Error(`Checksum verification failed. Expected ${expected}, actual ${actual}`);
+    throw new Error(
+      `Checksum verification failed. Expected ${expected}, actual ${actual}`,
+    );
   }
   console.log(`${LOG_PREFIX} Checksum verified.`);
 }
 
-function execFilePromise(command, args) {
+function execFilePromise(command, args, options = {}) {
   return new Promise((resolve, reject) => {
-    execFile(command, args, (error, stdout, stderr) => {
+    execFile(command, args, options, (error, stdout, stderr) => {
       if (error) {
         reject(
           new Error(
@@ -331,9 +552,28 @@ function execFilePromise(command, args) {
   });
 }
 
+function getPathApi(filePath) {
+  return /^[a-zA-Z]:[\\/]/.test(filePath) ? path.win32 : path;
+}
+
+function getTarExtractInvocation(archivePath, destDir) {
+  const pathApi = getPathApi(archivePath);
+  const cwd = pathApi.dirname(archivePath);
+  return {
+    cwd,
+    args: [
+      '-xzf',
+      pathApi.basename(archivePath),
+      '-C',
+      pathApi.relative(cwd, destDir) || '.',
+    ],
+  };
+}
+
 async function extractArchive(archivePath, destDir) {
-  if (archivePath.endsWith('.tar.gz')) {
-    await execFilePromise('tar', ['-xzf', archivePath, '-C', destDir]);
+  if (archivePath.endsWith('.tar.gz') || archivePath.endsWith('.tgz')) {
+    const invocation = getTarExtractInvocation(archivePath, destDir);
+    await execFilePromise('tar', invocation.args, { cwd: invocation.cwd });
     return;
   }
 
@@ -423,13 +663,102 @@ function installExtractedContents(extractDir, bundledDir) {
   }
 
   const files = fs.readdirSync(bundledDir);
-  console.log(`${LOG_PREFIX} Copied ${files.length} file(s) to _bundled: ${files.join(', ')}`);
+  console.log(
+    `${LOG_PREFIX} Copied ${files.length} file(s) to _bundled: ${files.join(', ')}`,
+  );
   return target;
 }
 
+function findWorkerRuntimeRoot(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const hasWorkerRuntime = entries.some(
+    (entry) =>
+      entry.isFile() &&
+      (entry.name === 'qoder-worker-runtime.obf.mjs' ||
+        entry.name === 'qoder-worker-runtime.mjs'),
+  );
+  if (hasWorkerRuntime) return dir;
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const nested = findWorkerRuntimeRoot(path.join(dir, entry.name));
+    if (nested) return nested;
+  }
+  return null;
+}
+
+function installExtractedWorkerRuntime(extractDir, workerDir) {
+  const contentRoot = findWorkerRuntimeRoot(extractDir);
+  if (!contentRoot) {
+    throw new Error(
+      'Worker runtime not found in extracted archive. Expected qoder-worker-runtime.obf.mjs or qoder-worker-runtime.mjs.',
+    );
+  }
+
+  fs.rmSync(workerDir, { recursive: true, force: true });
+  copyDirContents(contentRoot, workerDir);
+
+  const obfuscatedRuntime = path.join(
+    workerDir,
+    'qoder-worker-runtime.obf.mjs',
+  );
+  const plainRuntime = path.join(workerDir, 'qoder-worker-runtime.mjs');
+  const runtimePath = fs.existsSync(obfuscatedRuntime)
+    ? obfuscatedRuntime
+    : plainRuntime;
+  if (!fs.existsSync(runtimePath)) {
+    throw new Error(`Worker runtime copy failed: ${runtimePath}`);
+  }
+
+  const files = fs.readdirSync(workerDir);
+  console.log(
+    `${LOG_PREFIX} Copied ${files.length} file(s) to _worker: ${files.join(', ')}`,
+  );
+  return runtimePath;
+}
+
+async function installWorkerRuntimeFromDownload() {
+  const url = getWorkerRuntimeDownloadUrl();
+  const expectedSha256 = 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 {
+    await downloadWithRetry(url, archivePath);
+    await verifyChecksum(url, archivePath, expectedSha256);
+    fs.mkdirSync(extractDir, { recursive: true });
+    await extractArchive(archivePath, extractDir);
+    return installExtractedWorkerRuntime(
+      extractDir,
+      path.dirname(getPackagedWorkerRuntimePath()),
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
 async function main() {
   if (isTruthy(process.env.QODER_SKIP_DOWNLOAD)) {
-    console.log(`${LOG_PREFIX} QODER_SKIP_DOWNLOAD is set, skipping CLI download.`);
+    console.log(
+      `${LOG_PREFIX} QODER_SKIP_DOWNLOAD is set, skipping runtime downloads.`,
+    );
+    return;
+  }
+
+  if (shouldInstallWorkerRuntimeForDefaultWorker()) {
+    console.log(
+      `${LOG_PREFIX} Package default runtime is Worker; downloading Worker runtime.`,
+    );
+    await installWorkerRuntimeFromDownload();
+  }
+
+  if (shouldSkipBundledCliDownloadForWorkerRuntime()) {
+    console.log(
+      `${LOG_PREFIX} Package default runtime is Worker; skipping bundled CLI binary download. Set QODER_INSTALL_BUNDLED_CLI=1 to install the process fallback as well.`,
+    );
     return;
   }
 
@@ -448,7 +777,9 @@ async function main() {
   const archivePath = path.join(tempDir, archiveName);
   const extractDir = path.join(tempDir, 'extract');
 
-  console.log(`${LOG_PREFIX} Installing ${bundleName} ${version} for ${target}.`);
+  console.log(
+    `${LOG_PREFIX} Installing ${bundleName} ${version} for ${target}.`,
+  );
 
   try {
     fs.mkdirSync(extractDir, { recursive: true });
@@ -461,8 +792,12 @@ async function main() {
       `${LOG_PREFIX} CLI binary installed: ${installedPath} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`,
     );
   } catch (error) {
-    console.error(`${LOG_PREFIX} ERROR: Failed to install bundled CLI: ${error.message}`);
-    console.error(`${LOG_PREFIX} Set QODER_SKIP_DOWNLOAD=1 to skip download and use a system qodercli.`);
+    console.error(
+      `${LOG_PREFIX} ERROR: Failed to install bundled CLI: ${error.message}`,
+    );
+    console.error(
+      `${LOG_PREFIX} Set QODER_SKIP_DOWNLOAD=1 to skip download and use a system qodercli.`,
+    );
     process.exit(1);
   } finally {
     fs.rmSync(tempDir, { recursive: true, force: true });
@@ -477,15 +812,37 @@ if (require.main === module) {
 }
 
 module.exports = {
+  downloadWithRetry,
+  extractArchive,
+  getTarExtractInvocation,
   getArtifactName,
   getArchiveExtension,
   getCliSite,
   getCliVersion,
   getDownloadBaseUrl,
   getDownloadUrl,
+  getManifestWorkerRuntimeDownloadUrl,
+  getManifestWorkerRuntimeSha256,
+  getPackagedWorkerRuntimeInfoPath,
+  getPackagedWorkerRuntimePath,
+  getRuntimeManifestPath,
   getPlatformTarget,
+  getDefaultRuntimeTransport,
+  getWorkerRuntimeExpectedSha256,
+  getWorkerRuntimeArtifactName,
+  getWorkerRuntimeDownloadBaseUrl,
+  getWorkerRuntimeDownloadUrl,
+  hasPackagedWorkerRuntime,
   installExtractedContents,
+  installExtractedWorkerRuntime,
+  installWorkerRuntimeFromDownload,
+  isPackagedWorkerRuntimeCompatibleWithSite,
   isDevCliVersion,
   normalizeDownloadBaseUrl,
   normalizePlatformOverride,
+  readPackagedWorkerRuntimeInfo,
+  readRuntimeManifest,
+  shouldInstallWorkerRuntimeForDefaultWorker,
+  shouldSkipBundledCliDownloadForWorkerRuntime,
+  verifyChecksum,
 };