openxiangda 1.0.158 → 1.0.159

package/lib/cli.js

@@ -5924,6 +5924,8 @@ async function runDirectRequest(config, target, flags, request, options = {}) {
     method: request.method || 'GET',
     body: request.body,
     strictEnvelope: request.strictEnvelope,
+    timeoutMs:
+      request.timeoutMs || flags['timeout-ms'] || flags.timeout || undefined,
   };
   let data;
   if (request.auth === false) {

package/lib/http.js

@@ -1,8 +1,15 @@
 const { formatFetchError, maskText } = require('./utils');
 
-const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
+const DEFAULT_REQUEST_TIMEOUT_MS = normalizeTimeoutMs(
+  process.env.OPENXIANGDA_REQUEST_TIMEOUT_MS,
+  120000
+);
+const DEFAULT_CONNECT_TIMEOUT_MS = normalizeTimeoutMs(
+  process.env.OPENXIANGDA_CONNECT_TIMEOUT_MS,
+  30000
+);
 
-configureFetchDispatcher(DEFAULT_REQUEST_TIMEOUT_MS);
+configureFetchDispatcher(DEFAULT_CONNECT_TIMEOUT_MS);
 
 async function requestJson(baseUrl, apiPath, options = {}) {
   if (typeof fetch !== 'function') {
@@ -82,17 +89,106 @@ module.exports = {
 
 function configureFetchDispatcher(timeoutMs) {
   try {
-    // Node fetch uses undici internally. Setting the global dispatcher prevents
-    // large resource operations from failing on undici's 10s connect default.
-    const { Agent, setGlobalDispatcher } = require('undici');
-    setGlobalDispatcher(
-      new Agent({
-        connect: {
-          timeout: timeoutMs,
-        },
-      })
+    // Node fetch uses undici internally but does not honor proxy environment
+    // variables by itself. Keep NO_PROXY-aware routing while extending the
+    // connect timeout for private and high-latency deployments.
+    const { Agent, ProxyAgent, setGlobalDispatcher } = require('undici');
+    const connect = { timeout: timeoutMs };
+    const directAgent = new Agent({ connect });
+    const httpProxyUrl = readProxyUrl('HTTP_PROXY');
+    const httpsProxyUrl = readProxyUrl('HTTPS_PROXY') || httpProxyUrl;
+    const allProxyUrl = readProxyUrl('ALL_PROXY');
+    const httpProxyAgent = createProxyAgent(
+      ProxyAgent,
+      httpProxyUrl || allProxyUrl,
+      connect
     );
+    const httpsProxyAgent = createProxyAgent(
+      ProxyAgent,
+      httpsProxyUrl || allProxyUrl,
+      connect
+    );
+
+    setGlobalDispatcher({
+      dispatch(options, handler) {
+        const origin = new URL(String(options.origin));
+        if (shouldBypassProxy(origin)) {
+          return directAgent.dispatch(options, handler);
+        }
+        const proxyAgent =
+          origin.protocol === 'https:' ? httpsProxyAgent : httpProxyAgent;
+        return (proxyAgent || directAgent).dispatch(options, handler);
+      },
+      close() {
+        return closeDispatchers([
+          directAgent,
+          httpProxyAgent,
+          httpsProxyAgent,
+        ]);
+      },
+      destroy(error) {
+        return destroyDispatchers(
+          [directAgent, httpProxyAgent, httpsProxyAgent],
+          error
+        );
+      },
+    });
   } catch {
     // Keep working on runtimes where undici is not directly importable.
   }
 }
+
+function readProxyUrl(name) {
+  const value = process.env[name] || process.env[name.toLowerCase()];
+  return String(value || '').trim();
+}
+
+function createProxyAgent(ProxyAgent, uri, connect) {
+  if (!uri) return null;
+  return new ProxyAgent({ uri, connect });
+}
+
+function shouldBypassProxy(origin) {
+  const noProxy = readProxyUrl('NO_PROXY');
+  if (!noProxy) return false;
+  const hostname = origin.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+  const port = origin.port || (origin.protocol === 'https:' ? '443' : '80');
+
+  return noProxy.split(',').some(rawEntry => {
+    const entry = rawEntry.trim().toLowerCase();
+    if (!entry) return false;
+    if (entry === '*') return true;
+
+    const normalized = entry.replace(/^https?:\/\//, '');
+    const separator = normalized.lastIndexOf(':');
+    const hasSinglePortSeparator =
+      separator > -1 && normalized.indexOf(':') === separator;
+    const entryHost = (hasSinglePortSeparator
+      ? normalized.slice(0, separator)
+      : normalized
+    ).replace(/^\[|\]$/g, '');
+    const entryPort = hasSinglePortSeparator
+      ? normalized.slice(separator + 1)
+      : '';
+    if (entryPort && entryPort !== port) return false;
+
+    const suffix = entryHost.replace(/^\*?\./, '');
+    return hostname === suffix || hostname.endsWith(`.${suffix}`);
+  });
+}
+
+async function closeDispatchers(dispatchers) {
+  await Promise.all(
+    uniqueDispatchers(dispatchers).map(dispatcher => dispatcher.close())
+  );
+}
+
+async function destroyDispatchers(dispatchers, error) {
+  await Promise.all(
+    uniqueDispatchers(dispatchers).map(dispatcher => dispatcher.destroy(error))
+  );
+}
+
+function uniqueDispatchers(dispatchers) {
+  return [...new Set(dispatchers.filter(Boolean))];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.158",
+  "version": "1.0.159",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {
@@ -62,7 +62,7 @@
   "scripts": {
     "build:sdk": "tsup --config packages/sdk/tsup.config.ts",
     "check": "node --check bin/openxiangda.js && node --check lib/*.js && node --check packages/sdk/src/build-source/src/cli.mjs && node --check packages/sdk/src/build-source/scripts/*.mjs && node --check packages/sdk/src/build-source/scripts/utils/*.mjs",
-    "test": "npm run check && node scripts/form-export-cli-smoke.mjs && node scripts/open-api-cli-smoke.mjs",
+    "test": "npm run check && node scripts/http-proxy-smoke.mjs && node scripts/form-export-cli-smoke.mjs && node scripts/open-api-cli-smoke.mjs",
     "prepack": "npm run build:sdk",
     "test:profile-isolation": "bash scripts/profile-isolation-smoke.sh",
     "test:resource-plan": "node scripts/resource-plan-smoke.mjs",