scalemax 0.1.33 → 0.1.35

package/README.md

@@ -205,7 +205,7 @@ npx scalemax models
 ```
 
 The model list is fetched live from `https://api.scalemax.pro/v1/models` every time, so disabled or unsupported models disappear immediately without manual cache cleanup.
-Key metadata and the authenticated model catalog are fetched concurrently on the normal path. Safe GET checks receive one short, jittered retry on transient network, rate-limit, or server failures; model-generation POST requests are never retried by the installer.
+The CLI authenticates the key before loading its model catalog. Safe GET checks receive one short, jittered retry on transient network, rate-limit, or server failures; model-generation POST requests are never retried by the installer. CLI requests honor `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` and automatically try the usable IPv4 or IPv6 route.
 
 Run diagnostics:
 
@@ -289,6 +289,20 @@ Or clear the npm cache:
 npm cache verify
 ```
 
+### `Could not reach the ScaleMax API`
+
+Use the latest CLI first:
+
+```bash
+npx scalemax@latest
+```
+
+ScaleMax automatically honors `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY`
+when a workplace or ISP requires an outbound proxy. It also falls back between
+IPv4 and IPv6. If the error specifically reports DNS or TLS, correct the
+device DNS/system clock or disable HTTPS inspection for `api.scalemax.pro`,
+then rerun the command. Never disable TLS verification.
+
 ### Client config looks wrong
 
 Run:

package/dist/configure/roo-code.js

@@ -17,6 +17,7 @@ const codexProfileId = 'scalemax-codex';
 const claudeProfileId = 'scalemax-claude';
 const deepSeekProfileId = 'scalemax-deepseek';
 const glmProfileId = 'scalemax-glm-5-2';
+const rooMaximumOutputTokens = 384_000;
 function exactChatProfile(ctx, model) {
     if (model.trim().toLowerCase() === 'glm-5.2')
         return { name: glmProfileName, id: glmProfileId, model };
@@ -30,7 +31,10 @@ function positiveInteger(value, fallback) {
 function rooModelInfo(ctx, modelId) {
     const model = (ctx.models || []).find(candidate => candidate.id.trim() === modelId.trim());
     const contextWindow = positiveInteger(model?.context_window, 128_000);
-    const maxTokens = Math.min(contextWindow, positiveInteger(model?.max_output_tokens, 4_096));
+    // Roo sends this value as max_completion_tokens. Keep it within the
+    // ScaleMax/OpenAI-compatible contract even if an upstream catalog
+    // accidentally reports an output window larger than the public API accepts.
+    const maxTokens = Math.min(rooMaximumOutputTokens, contextWindow, positiveInteger(model?.max_output_tokens, 4_096));
     const capabilities = model?.capabilities;
     return {
         maxTokens,
@@ -128,7 +132,13 @@ function handoff(ctx) {
             apiConfigs,
             modeApiConfigs: {}
         },
-        globalSettings: {}
+        globalSettings: {
+            // Roo 3.54 still probes an obsolete bundled-ripgrep path while building
+            // automatic workspace snapshots on newer VS Code releases. Disabling
+            // only that snapshot prevents its recursive request loop; Roo's explicit
+            // read/search/edit tools remain available to the selected model.
+            maxWorkspaceFiles: 0
+        }
     }, null, 2) + '\n';
 }
 export async function configure(ctx) {
@@ -171,6 +181,9 @@ export async function verify(ctx) {
     if (settings[importSetting] !== importSettingValue || profile?.providerProfiles?.currentApiConfigName !== current.name) {
         throw new Error('Roo Code auto-import handoff is incomplete.');
     }
+    if (profile?.globalSettings?.maxWorkspaceFiles !== 0) {
+        throw new Error('Roo Code reliability settings are incomplete.');
+    }
     for (const expected of expectedProfiles) {
         const config = profile?.providerProfiles?.apiConfigs?.[expected.name];
         const expectedModelInfo = rooModelInfo(ctx, expected.model);

package/dist/utils/api.js

@@ -1,5 +1,6 @@
 import { SCALEMAX_BASE_URL, SCALEMAX_TOKEN_BASE_URL } from '../constants.js';
 import { redactApiKey, sanitizeApiKey } from './apiKey.js';
+import { scaleMaxFetch } from './network.js';
 export const DEEPSEEK_V4_FLASH_SCOPE = 'deepseek-v4-flash';
 export const GLM_5_2_SCOPE = 'glm-5.2';
 // Keep only aliases that are no longer offered. Direct GPT-5.6 Sol is an
@@ -77,9 +78,21 @@ function retryableStatus(status) {
 }
 function safeTransportError(error, timeoutSeconds) {
     const message = error instanceof Error ? error.message : String(error);
+    const cause = error && typeof error === 'object' && 'cause' in error
+        ? error.cause
+        : undefined;
+    const code = cause && typeof cause === 'object' && 'code' in cause
+        ? String(cause.code || '').toUpperCase()
+        : '';
     if (/abort|timeout|timed?\s*out/i.test(message)) {
         return `ScaleMax request timed out after ${timeoutSeconds} seconds. Please try again.`;
     }
+    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
+        return 'Could not resolve the ScaleMax API hostname. Check this device’s DNS settings, then retry.';
+    }
+    if (/CERT|TLS|SSL|SELF_SIGNED|UNABLE_TO_VERIFY/.test(code)) {
+        return 'The ScaleMax TLS certificate could not be verified. Check the system clock and any HTTPS-inspecting proxy or antivirus, then retry.';
+    }
     // Native fetch intentionally hides DNS/TLS/proxy details behind the generic
     // "fetch failed" message. It is not an authentication verdict and may
     // contain environment-specific detail that is not useful in an installer.
@@ -90,6 +103,8 @@ async function request(path, apiKey, init = {}, retryGet = false, baseUrl = SCAL
     if (apiKey)
         headers.set('Authorization', `Bearer ${sanitizeApiKey(apiKey)}`);
     headers.set('Cache-Control', 'no-cache');
+    headers.set('Accept', 'application/json');
+    headers.set('User-Agent', 'ScaleMax-CLI');
     if (!headers.has('Content-Type') && init.body)
         headers.set('Content-Type', 'application/json');
     const attempts = retryGet && (!init.method || init.method === 'GET') ? 2 : 1;
@@ -98,7 +113,7 @@ async function request(path, apiKey, init = {}, retryGet = false, baseUrl = SCAL
         const timeout = AbortSignal.timeout(timeoutMs);
         const signal = init.signal && typeof AbortSignal.any === 'function' ? AbortSignal.any([init.signal, timeout]) : timeout;
         try {
-            const response = await fetch(`${baseUrl}${path}`, { ...init, headers, signal });
+            const response = await scaleMaxFetch(`${baseUrl}${path}`, { ...init, headers, signal }, attempt > 0);
             if (attempt + 1 === attempts || !retryableStatus(response.status))
                 return response;
             await response.body?.cancel().catch(() => undefined);

package/dist/utils/network.d.ts

@@ -0,0 +1,5 @@
+import { type Dispatcher } from 'undici';
+export type ScaleMaxFetchInit = RequestInit & {
+    dispatcher: Dispatcher;
+};
+export declare function scaleMaxFetch(input: string | URL, init?: RequestInit, allowProxyFallback?: boolean): Promise<Response>;

package/dist/utils/network.js

@@ -0,0 +1,91 @@
+import { Agent, ProxyAgent } from 'undici';
+/*
+ * Node's built-in fetch does not consistently honor HTTP(S)_PROXY/NO_PROXY
+ * across the supported Node 18-22 range. It can also wait on an unusable
+ * IPv6 route instead of trying the working IPv4 address. The CLI is a
+ * network installer, so use an explicit dispatcher that handles both cases.
+ *
+ * RFC 8305-style family selection races the available A/AAAA routes instead
+ * of assuming the first DNS result is usable. ProxyAgent is used explicitly
+ * rather than Undici's experimental EnvHttpProxyAgent so customers do not see
+ * runtime stability warnings.
+ */
+const directDispatcher = new Agent({
+    autoSelectFamily: true,
+    autoSelectFamilyAttemptTimeout: 250
+});
+const proxyDispatchers = new Map();
+const proxyPreferredOrigins = new Set();
+function environmentValue(lowercase, uppercase) {
+    return String(process.env[lowercase] || process.env[uppercase] || '').trim();
+}
+function defaultPort(url) {
+    return url.port || (url.protocol === 'https:' ? '443' : '80');
+}
+function splitNoProxyEntry(entry) {
+    const value = entry.trim().toLowerCase();
+    if (value.startsWith('[')) {
+        const end = value.indexOf(']');
+        if (end >= 0) {
+            const port = value.slice(end + 1).replace(/^:/, '') || undefined;
+            return { hostname: value.slice(1, end), port };
+        }
+    }
+    const colon = value.lastIndexOf(':');
+    if (colon > -1 && value.indexOf(':') === colon && /^\d+$/.test(value.slice(colon + 1))) {
+        return { hostname: value.slice(0, colon), port: value.slice(colon + 1) };
+    }
+    return { hostname: value };
+}
+function bypassesProxy(url) {
+    const raw = environmentValue('no_proxy', 'NO_PROXY');
+    if (!raw)
+        return false;
+    const hostname = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    const port = defaultPort(url);
+    return raw.split(/[,\s]+/).filter(Boolean).some(candidate => {
+        if (candidate === '*')
+            return true;
+        const parsed = splitNoProxyEntry(candidate);
+        if (parsed.port && parsed.port !== port)
+            return false;
+        const rule = parsed.hostname.replace(/^\*\./, '').replace(/^\./, '');
+        return hostname === rule || hostname.endsWith(`.${rule}`);
+    });
+}
+function proxyFor(url) {
+    if (bypassesProxy(url))
+        return undefined;
+    if (url.protocol === 'https:') {
+        return environmentValue('https_proxy', 'HTTPS_PROXY')
+            || environmentValue('http_proxy', 'HTTP_PROXY')
+            || undefined;
+    }
+    return environmentValue('http_proxy', 'HTTP_PROXY') || undefined;
+}
+function dispatcherFor(url) {
+    const proxy = proxyFor(url);
+    if (!proxy)
+        return directDispatcher;
+    let dispatcher = proxyDispatchers.get(proxy);
+    if (!dispatcher) {
+        dispatcher = new ProxyAgent({
+            uri: proxy,
+            autoSelectFamily: true,
+            autoSelectFamilyAttemptTimeout: 250
+        });
+        proxyDispatchers.set(proxy, dispatcher);
+    }
+    return dispatcher;
+}
+export async function scaleMaxFetch(input, init = {}, allowProxyFallback = false) {
+    const url = input instanceof URL ? input : new URL(input);
+    const proxy = proxyFor(url);
+    const useProxy = Boolean(proxy)
+        && (allowProxyFallback || proxyPreferredOrigins.has(url.origin));
+    const dispatcher = useProxy ? dispatcherFor(url) : directDispatcher;
+    const response = await fetch(input, { ...init, dispatcher });
+    if (useProxy)
+        proxyPreferredOrigins.add(url.origin);
+    return response;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {
@@ -33,6 +33,7 @@
     "fs-extra": "^11.2.0",
     "json5": "^2.2.3",
     "ora": "^8.1.1",
+    "undici": "^6.28.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {