@orchagent/cli 0.3.62 → 0.3.63

package/dist/index.js

@@ -44,6 +44,7 @@ if (process.env.SENTRY_DSN) {
 const commander_1 = require("commander");
 const commands_1 = require("./commands");
 const errors_1 = require("./lib/errors");
+const suggest_1 = require("./lib/suggest");
 const analytics_1 = require("./lib/analytics");
 const config_1 = require("./lib/config");
 const spinner_1 = require("./lib/spinner");
@@ -73,6 +74,7 @@ Documentation: https://docs.orchagent.io
   orchagent docs agents  Building agents guide
 `);
 (0, commands_1.registerCommands)(program);
+(0, suggest_1.enhanceUnknownOptionSuggestions)(program);
 // Initialize progress setting before parsing
 async function main() {
     // Check config for no_progress setting

package/dist/lib/api.js

@@ -109,13 +109,38 @@ async function safeFetchWithRetryForCalls(url, options) {
             }
             // Retry on 5xx or 429
             if (response.status >= 500 || response.status === 429) {
+                // Read body to check if error is retryable
+                const bodyText = await response.text().catch(() => '');
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(bodyText);
+                }
+                catch { /* ignore */ }
+                const detail = parsed?.error?.message ||
+                    parsed?.message || '';
+                const isRetryable = parsed?.error?.is_retryable;
+                // Don't retry if server explicitly says error is not retryable
+                if (isRetryable === false) {
+                    return new Response(bodyText, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers,
+                    });
+                }
                 if (attempt < MAX_RETRIES) {
                     const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
                     const jitter = Math.random() * 500;
-                    process.stderr.write(`Request failed (${response.status}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                    const detailSuffix = detail ? `: ${detail}` : '';
+                    process.stderr.write(`Request failed (${response.status}${detailSuffix}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
                     await new Promise(r => setTimeout(r, delay + jitter));
                     continue;
                 }
+                // Last attempt — return reconstructed response (body was consumed)
+                return new Response(bodyText, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                });
             }
             return response;
         }
@@ -142,13 +167,38 @@ async function safeFetchWithRetry(url, options) {
             }
             // Retry on 5xx or 429
             if (response.status >= 500 || response.status === 429) {
+                // Read body to check if error is retryable
+                const bodyText = await response.text().catch(() => '');
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(bodyText);
+                }
+                catch { /* ignore */ }
+                const detail = parsed?.error?.message ||
+                    parsed?.message || '';
+                const isRetryable = parsed?.error?.is_retryable;
+                // Don't retry if server explicitly says error is not retryable
+                if (isRetryable === false) {
+                    return new Response(bodyText, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers,
+                    });
+                }
                 if (attempt < MAX_RETRIES) {
                     const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
                     const jitter = Math.random() * 500;
-                    process.stderr.write(`Request failed (${response.status}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                    const detailSuffix = detail ? `: ${detail}` : '';
+                    process.stderr.write(`Request failed (${response.status}${detailSuffix}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
                     await new Promise(r => setTimeout(r, delay + jitter));
                     continue;
                 }
+                // Last attempt — return reconstructed response (body was consumed)
+                return new Response(bodyText, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                });
             }
             return response;
         }

package/dist/lib/dotenv.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDotEnv = parseDotEnv;
+exports.loadDotEnv = loadDotEnv;
+exports.mergeEnv = mergeEnv;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Parse a .env file into key-value pairs.
+ * Handles: comments (#), blank lines, KEY=VALUE, single/double quoted values.
+ * Does NOT support multiline values or variable expansion.
+ */
+function parseDotEnv(content) {
+    const vars = {};
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const eqIndex = line.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = line.slice(0, eqIndex).trim();
+        if (!key)
+            continue;
+        let value = line.slice(eqIndex + 1).trim();
+        // Strip matching quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        vars[key] = value;
+    }
+    return vars;
+}
+/**
+ * Load .env file from a directory. Returns the parsed vars (empty object if no file).
+ * Does NOT modify process.env — caller decides how to merge.
+ */
+async function loadDotEnv(dir) {
+    const envPath = path_1.default.join(dir, '.env');
+    try {
+        const content = await promises_1.default.readFile(envPath, 'utf-8');
+        return parseDotEnv(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Merge .env vars into an env object. Existing keys take precedence
+ * (process.env wins over .env file, matching standard dotenv behaviour).
+ */
+function mergeEnv(base, dotEnvVars) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(dotEnvVars)) {
+        if (!(key in merged) || merged[key] === undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}

package/dist/lib/errors.js

@@ -58,7 +58,13 @@ function formatError(err) {
     if (err instanceof Error) {
         const anyErr = err;
         if (anyErr.status && anyErr.payload) {
-            return `${anyErr.message} (status ${anyErr.status})`;
+            const p = anyErr.payload;
+            const code = p.error?.code;
+            const detail = p.error?.detail || p.detail;
+            let msg = `${anyErr.message} (status ${anyErr.status}${code ? `, ${code}` : ''})`;
+            if (detail)
+                msg += `\n${detail}`;
+            return msg;
         }
         return anyErr.message;
     }

package/dist/lib/suggest.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editDistance = editDistance;
+exports.findBestMatch = findBestMatch;
+exports.enhanceUnknownOptionSuggestions = enhanceUnknownOptionSuggestions;
+// ---------------------------------------------------------------------------
+// Hints for flags that aren't typos but semantic misunderstandings.
+// Keyed by command name → flag → helpful message.
+// ---------------------------------------------------------------------------
+const COMMAND_HINTS = {
+    run: {
+        '--cloud': 'Cloud execution is the default. Use --local for local execution.',
+    },
+};
+// ---------------------------------------------------------------------------
+// Damerau-Levenshtein distance (same algorithm commander uses internally)
+// ---------------------------------------------------------------------------
+function editDistance(a, b) {
+    const MAX = Math.max(a.length, b.length);
+    if (Math.abs(a.length - b.length) > MAX)
+        return MAX;
+    const d = [];
+    for (let i = 0; i <= a.length; i++)
+        d[i] = [i];
+    for (let j = 0; j <= b.length; j++)
+        d[0][j] = j;
+    for (let j = 1; j <= b.length; j++) {
+        for (let i = 1; i <= a.length; i++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            d[i][j] = Math.min(d[i - 1][j] + 1, // deletion
+            d[i][j - 1] + 1, // insertion
+            d[i - 1][j - 1] + cost // substitution
+            );
+            // transposition
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+            }
+        }
+    }
+    return d[a.length][b.length];
+}
+// ---------------------------------------------------------------------------
+// Find the best matching option flag for an unknown flag.
+//
+// Enhancements over commander's built-in:
+// - For --no-X options, also compares the unknown against the bare X name.
+//   This lets --strem match --no-stream (comparing "strem" vs "stream").
+// ---------------------------------------------------------------------------
+const MIN_SIMILARITY = 0.4;
+const MAX_DISTANCE = 3;
+function isSimilarEnough(dist, wordLen, candidateLen) {
+    if (dist > MAX_DISTANCE)
+        return false;
+    const len = Math.max(wordLen, candidateLen);
+    return (len - dist) / len > MIN_SIMILARITY;
+}
+function findBestMatch(unknownFlag, candidateFlags) {
+    if (!candidateFlags.length)
+        return null;
+    const unknown = unknownFlag.replace(/^--?/, '');
+    let bestFlag = null;
+    let bestDist = MAX_DISTANCE + 1;
+    for (const candidate of candidateFlags) {
+        const name = candidate.replace(/^--?/, '');
+        if (name.length <= 1)
+            continue;
+        // Standard comparison
+        const dist = editDistance(unknown, name);
+        if (dist < bestDist && isSimilarEnough(dist, unknown.length, name.length)) {
+            bestDist = dist;
+            bestFlag = candidate;
+        }
+        // Negation-aware: for --no-X, also compare unknown against X
+        if (name.startsWith('no-')) {
+            const baseName = name.slice(3);
+            if (baseName.length <= 1)
+                continue;
+            const baseDist = editDistance(unknown, baseName);
+            if (baseDist < bestDist && isSimilarEnough(baseDist, unknown.length, baseName.length)) {
+                bestDist = baseDist;
+                bestFlag = candidate;
+            }
+        }
+    }
+    return bestFlag;
+}
+// ---------------------------------------------------------------------------
+// Override unknownOption on a command tree to provide enhanced suggestions.
+// ---------------------------------------------------------------------------
+function getHint(commandName, flag) {
+    return COMMAND_HINTS[commandName]?.[flag] ?? null;
+}
+function gatherCandidateFlags(cmd) {
+    const flags = [];
+    let current = cmd;
+    do {
+        const moreFlags = current
+            .createHelp()
+            .visibleOptions(current)
+            .filter((opt) => opt.long)
+            .map((opt) => opt.long);
+        flags.push(...moreFlags);
+        current = current.parent;
+    } while (current && !current._enablePositionalOptions);
+    return [...new Set(flags)];
+}
+function overrideUnknownOption(cmd) {
+    ;
+    cmd.unknownOption = function (flag) {
+        if (this._allowUnknownOption)
+            return;
+        // 1. Check for a context-aware hint
+        const hint = getHint(this.name(), flag);
+        if (hint) {
+            this.error(`error: unknown option '${flag}'\n${hint}`, {
+                code: 'commander.unknownOption',
+            });
+            return;
+        }
+        // 2. Gather candidate flags and find best match (enhanced)
+        let suggestion = '';
+        if (flag.startsWith('--')) {
+            const candidates = gatherCandidateFlags(this);
+            const match = findBestMatch(flag, candidates);
+            if (match) {
+                suggestion = `\n(Did you mean ${match}?)`;
+            }
+        }
+        this.error(`error: unknown option '${flag}'${suggestion}`, {
+            code: 'commander.unknownOption',
+        });
+    };
+}
+/**
+ * Walk the full command tree and override unknownOption on every command.
+ * Call this after all commands have been registered.
+ */
+function enhanceUnknownOptionSuggestions(program) {
+    function walk(cmd) {
+        overrideUnknownOption(cmd);
+        for (const sub of cmd.commands) {
+            walk(sub);
+        }
+    }
+    walk(program);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.62",
+  "version": "0.3.63",
   "description": "Command-line interface for orchagent — deploy and run AI agents for your team",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",