@emend-ai/utim 1.43.6 → 1.43.9

package/bin/utim.js

@@ -1,146 +1,211 @@
 #!/usr/bin/env node
 
+/**
+ * UTIM CLI Launcher
+ *
+ * Zero-friction UX: `npm install -g @emend-ai/utim` then just run `utim`.
+ * Automatically installs the Python engine on first run if needed.
+ */
+
 const { spawnSync, spawn } = require('child_process');
-const path = require('path');
-const os = require('os');
-const fs = require('fs');
+const os   = require('os');
+const fs   = require('fs');
 
-const args = process.argv.slice(2);
-const isWin = os.platform() === 'win32';
+const args     = process.argv.slice(2);
+const isWin    = os.platform() === 'win32';
+const isMac    = os.platform() === 'darwin';
 const isTermux =
     (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) ||
     fs.existsSync('/data/data/com.termux');
 
+// ── Spinner (no-op when not a TTY) ───────────────────────────────────────────
+function createSpinner(text) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    if (!process.stderr.isTTY) {
+        process.stderr.write(text + '\n');
+        return { stop: (msg) => { if (msg) process.stderr.write(msg + '\n'); } };
+    }
+    const iv = setInterval(() => {
+        process.stderr.write(`\r${frames[i++ % frames.length]}  ${text}  `);
+    }, 80);
+    return {
+        stop: (msg) => {
+            clearInterval(iv);
+            process.stderr.write('\r' + ' '.repeat(text.length + 6) + '\r');
+            if (msg) process.stderr.write(msg + '\n');
+        }
+    };
+}
+
 // ── Find a working Python 3 interpreter ──────────────────────────────────────
 function findPython() {
     const candidates = isWin
         ? ['python', 'python3', 'py']
         : ['python3', 'python'];
 
-    for (const candidate of candidates) {
+    for (const cmd of candidates) {
         try {
-            const r = spawnSync(candidate, ['--version'], {
+            const r = spawnSync(cmd, ['--version'], {
                 encoding: 'utf8',
-                timeout: 4000,
+                timeout: 5000,
                 shell: isWin,
+                windowsHide: true,
             });
             const out = (r.stdout || '') + (r.stderr || '');
-            if (out.includes('Python 3')) return candidate;
+            if (out.includes('Python 3')) return cmd;
         } catch (_) {}
     }
     return null;
 }
 
-// ── Check if a binary is actually available and runnable ─────────────────────
-function commandExists(cmd) {
+// ── Check if utim-cli is installed via pip show (does NOT import the module) ─
+// Using pip show avoids false negatives caused by broken/missing transitive deps.
+function isUtimInstalled(python) {
     try {
-        // Use 'where' on Windows, 'which' on Unix to check existence
-        const checker = isWin ? 'where' : 'which';
-        const probe = spawnSync(checker, [cmd], {
+        const r = spawnSync(python, ['-m', 'pip', 'show', 'utim-cli'], {
             encoding: 'utf8',
-            timeout: 3000,
-            shell: false,
+            timeout: 10000,
+            shell: isWin,
+            windowsHide: true,
         });
-        return probe.status === 0 && (probe.stdout || '').trim().length > 0;
+        return r.status === 0 && (r.stdout || '').includes('Name:');
     } catch (_) {
         return false;
     }
 }
 
-// ── Launch a command, forwarding stdio ───────────────────────────────────────
-function launch(cmd, launchArgs) {
-    const proc = spawn(cmd, launchArgs, {
-        stdio: 'inherit',
-        shell: isWin,
-    });
-    proc.on('exit', (code) => process.exit(code == null ? 0 : code));
-    proc.on('error', () => {
-        // If spawning fails at OS level, fall through (caller handles)
-    });
-    return true;
-}
-
-// ── Try the installed console_script entry point ──────────────────────────────
-function tryEntryPoint() {
-    // Explicitly verify the binary exists before attempting to spawn it.
-    // This prevents the "not recognised as internal or external command" error
-    // from surfacing to the user when pip install was skipped.
-    if (!commandExists('utim-agent-core')) return false;
-    return launch('utim-agent-core', args);
-}
-
-// ── Try via `python -m utim_cli.utim` ───────────────────────────────────────
-function tryModule(python) {
+// ── Run pip install with given extra flags — always show output ───────────────
+function runPip(python, extraFlags) {
     try {
-        const probe = spawnSync(
+        const r = spawnSync(
             python,
-            ['-c', 'import utim_cli'],
-            { shell: isWin, timeout: 5000 }
+            ['-m', 'pip', 'install', '--upgrade', ...extraFlags, 'utim-cli'],
+            {
+                stdio: 'inherit',   // Always show output so errors are visible
+                shell: isWin,
+                windowsHide: false,
+                timeout: 300000,
+            }
         );
-        if (probe.status === 0) {
-            return launch(python, ['-m', 'utim_cli.utim', ...args]);
-        }
-    } catch (_) {}
-    return false;
+        return r.status === 0;
+    } catch (_) {
+        return false;
+    }
 }
 
-// ── Install from PyPI then retry ─────────────────────────────────────────────
-function selfInstallAndRun(python) {
-    console.error('\n⚙  First run: installing UTIM Python engine from PyPI...\n');
-
-    // On Termux, prebuilt packages must be installed first
+// ── Install UTIM engine — tries multiple strategies ───────────────────────────
+function installEngine(python) {
+    // Termux: install prebuilt system packages first to skip pydantic-core compilation
     if (isTermux) {
-        console.error(
-            '💡 Termux detected. Installing prebuilt dependencies first...\n' +
-            '   Run these commands if install fails:\n' +
-            '     pkg install python-cryptography python-pydantic\n' +
-            '     pip install utim-cli\n'
+        process.stderr.write(
+            '\n💡 Termux: installing prebuilt system dependencies first...\n\n'
         );
+        spawnSync('pkg', ['install', '-y', 'python-cryptography', 'python-pydantic'], {
+            stdio: 'inherit',
+            shell: false,
+        });
+        spawnSync(python, ['-m', 'pip', 'install', '--upgrade', 'pip', 'setuptools', 'wheel'], {
+            stdio: 'pipe',
+            shell: false,
+            timeout: 60000,
+        });
     }
 
-    const install = spawnSync(
-        python,
-        ['-m', 'pip', 'install', '--upgrade', 'utim-cli'],
-        { stdio: 'inherit', shell: isWin }
-    );
+    const spinner = createSpinner('Setting up UTIM (first run)');
+    spinner.stop('\n⚙  Installing UTIM Python engine...\n');
 
-    if (install.status !== 0) return false;
+    // Strategy 1: standard install
+    if (runPip(python, [])) return true;
 
-    // Retry both paths after install
-    return tryEntryPoint() || tryModule(python);
-}
+    // Strategy 2: --user (needed on systems where global site-packages is read-only)
+    process.stderr.write('\n   Retrying with --user flag...\n\n');
+    if (runPip(python, ['--user'])) return true;
 
-// ── Main ─────────────────────────────────────────────────────────────────────
-const python = findPython();
+    // Strategy 3: upgrade pip first, then retry both
+    process.stderr.write('\n   Upgrading pip and retrying...\n\n');
+    spawnSync(python, ['-m', 'pip', 'install', '--upgrade', 'pip'], {
+        stdio: 'pipe', shell: isWin, windowsHide: true, timeout: 60000,
+    });
+    if (runPip(python, [])) return true;
+    if (runPip(python, ['--user'])) return true;
 
-const ok =
-    tryEntryPoint() ||
-    (python && tryModule(python)) ||
-    (python && selfInstallAndRun(python));
+    return false;
+}
+
+// ── Launch UTIM Python engine ─────────────────────────────────────────────────
+function launch(python) {
+    const proc = spawn(python, ['-m', 'utim_cli.utim', ...args], {
+        stdio: 'inherit',
+        shell: false,
+        windowsHide: false,
+    });
+    proc.on('exit', (code) => process.exit(code == null ? 0 : code));
+    proc.on('error', (err) => {
+        process.stderr.write(
+            `\n❌  Could not start UTIM: ${err.message}\n\n` +
+            'Try reinstalling:\n' +
+            `  ${python} -m pip install --upgrade utim-cli\n\n`
+        );
+        process.exit(1);
+    });
+}
 
-if (!ok) {
-    console.error('\n❌  UTIM Engine could not start.\n');
+// ── Friendly "Python not found" message ──────────────────────────────────────
+function noPythonError() {
+    process.stderr.write('\n❌  Python 3 is required but was not found.\n\n');
     if (isTermux) {
-        console.error(
-            '💡 Termux: Prebuilt packages are required to avoid compilation errors.\n' +
-            '   Run:\n' +
-            '     pkg install python-cryptography python-pydantic\n' +
-            '     pip install utim-cli\n'
+        process.stderr.write('Run:  pkg install python\nThen:  utim\n\n');
+    } else if (isMac) {
+        process.stderr.write(
+            'Install:  brew install python\n' +
+            'Or:       https://python.org\n' +
+            'Then:     utim\n\n'
         );
-    } else if (!python) {
-        console.error(
-            'Python 3 was not found on this system.\n' +
-            'Please install Python 3.9+ from https://python.org\n' +
-            'Then run:  pip install utim-cli\n'
+    } else if (isWin) {
+        process.stderr.write(
+            'Download from https://python.org\n' +
+            '✔ Check "Add Python to PATH" during setup.\n' +
+            'Then:  utim\n\n'
         );
     } else {
-        console.error(
-            `Python found at: ${python}\n` +
-            'The UTIM Python engine is not installed. Please run:\n' +
-            '  pip install utim-cli\n' +
-            'or:\n' +
-            '  pip3 install --upgrade utim-cli\n'
+        process.stderr.write(
+            'sudo apt install python3 python3-pip   # Debian/Ubuntu\n' +
+            'sudo dnf install python3               # Fedora/RHEL\n' +
+            'Then:  utim\n\n'
         );
     }
     process.exit(1);
 }
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+const python = findPython();
+if (!python) noPythonError();
+
+if (!isUtimInstalled(python)) {
+    const pipOk = installEngine(python);
+
+    if (!isUtimInstalled(python)) {
+        if (pipOk) {
+            // pip said success but `pip show` still doesn't see it —
+            // environment mismatch (e.g. multiple Python installs).
+            // Attempt launch anyway; Python's own error will be informative.
+            process.stderr.write(
+                '\n⚠  Installed but could not verify — launching anyway...\n\n'
+            );
+        } else {
+            // pip failed — output was already shown above by inherit stdio
+            process.stderr.write(
+                '\n❌  Automatic installation failed (see pip errors above).\n\n' +
+                'Common fixes:\n' +
+                `  ${python} -m pip install --user utim-cli\n` +
+                '  python -m pip install --upgrade pip && pip install utim-cli\n\n' +
+                'Then run:  utim\n\n'
+            );
+            process.exit(1);
+        }
+    }
+}
+
+// Launch — even if verification was uncertain, let Python report a real error
+launch(python);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emend-ai/utim",
-  "version": "1.43.6",
+  "version": "1.43.9",
   "description": "UTIM – Universal Terminal Intelligence Manager. An agentic AI coding assistant for your terminal.",
   "keywords": [
     "ai",

package/scripts/postinstall.js

@@ -1,30 +1,31 @@
 /**
- * Cross-platform postinstall script for @emend-ai/utim.
+ * Optional postinstall pre-warm for @emend-ai/utim.
  *
- * After `npm install -g @emend-ai/utim`, this script runs automatically to:
- *   1. Locate a Python 3 interpreter on the user's machine.
- *   2. Install the UTIM Python engine from PyPI:  pip install utim-cli
- *   3. Set the execute bit on bin/utim.js (Unix / Termux only).
+ * This is a best-effort pre-installation of the UTIM Python engine.
+ * If it fails for ANY reason, we exit 0 — the main launcher (bin/utim.js)
+ * will handle installation automatically on first run with a clean spinner.
  *
- * The Python source code is NOT bundled inside this npm package.
- * It is fetched from PyPI at install time.
+ * This script exists purely to make the first `utim` launch faster
+ * by pre-installing the Python engine during `npm install`.
  */
 const { spawnSync } = require('child_process');
-const path = require('path');
-const os   = require('os');
-const fs   = require('fs');
+const os = require('os');
+const fs = require('fs');
 
-const useShell = os.platform() === 'win32';
-const pkgDir = path.resolve(__dirname, '..');
+const isWin = os.platform() === 'win32';
+const isTermux =
+    (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) ||
+    fs.existsSync('/data/data/com.termux');
 
-// ── Find a usable Python 3 interpreter ────────────────────────────────────────
 function findPython() {
-    for (const candidate of ['python3', 'python']) {
+    const candidates = isWin ? ['python', 'python3', 'py'] : ['python3', 'python'];
+    for (const candidate of candidates) {
         try {
             const r = spawnSync(candidate, ['--version'], {
                 encoding: 'utf8',
                 timeout: 4000,
-                shell: useShell,
+                shell: isWin,
+                windowsHide: true,
             });
             const out = (r.stdout || '') + (r.stderr || '');
             if (out.includes('Python 3')) return candidate;
@@ -33,68 +34,48 @@ function findPython() {
     return null;
 }
 
-// ── Install UTIM Python engine from PyPI ──────────────────────────────────────
-function installFromPyPI(python) {
-    console.log('\n⚙  Installing UTIM Python engine from PyPI (pip install utim-cli)...\n');
-    try {
-        const r = spawnSync(
-            python,
-            ['-m', 'pip', 'install', '--upgrade', 'utim-cli'],
-            { stdio: 'inherit', shell: useShell }
-        );
-        return r.status === 0;
-    } catch (_) {
-        return false;
-    }
-}
-
-// ── Set execute bit on Unix / Termux ─────────────────────────────────────────
+// Set execute bit on Unix / macOS / Termux
 function setExecuteBit() {
-    if (os.platform() !== 'win32') {
-        const binFile = path.join(pkgDir, 'bin', 'utim.js');
+    if (!isWin) {
         try {
+            const binFile = require('path').join(__dirname, '..', 'bin', 'utim.js');
             fs.chmodSync(binFile, 0o755);
-        } catch (_) {
-            // non-fatal — npm usually sets the bit itself via package.json "bin"
-        }
+        } catch (_) {}
     }
 }
 
-// ── Main ──────────────────────────────────────────────────────────────────────
-const python = findPython();
+setExecuteBit();
 
-if (!python) {
-    console.error(
-        '\n⚠  Python 3 not found on this machine.\n' +
-        '   Please install Python 3.9+ from https://python.org and then run:\n' +
-        '     pip install utim-cli\n' +
-        '   to finish setting up UTIM.\n'
-    );
-    // Exit 0 so npm does not roll back the install — user can pip install manually
+// Skip pre-warm on Termux — needs prebuilt pkg packages first,
+// which the main launcher handles properly with user guidance.
+if (isTermux) {
     process.exit(0);
 }
 
-const ok = installFromPyPI(python);
-setExecuteBit();
-
-if (ok) {
-    console.log('\n✅  UTIM installed successfully. Run  utim  to get started.\n');
-} else {
-    const isTermux = (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) || fs.existsSync('/data/data/com.termux');
-    if (isTermux) {
-        console.warn(
-            '\n💡 Note for Termux Users: Precompiled binaries are required to avoid Rust compiler errors (pydantic-core).\n' +
-            '   Please run:  pkg install python-cryptography python-pydantic\n' +
-            '   And then:    pip install utim-cli\n'
-        );
-    } else {
-        console.warn(
-            '\n⚠  pip install failed. Try running manually:\n' +
-            '     pip install utim-cli\n' +
-            '   or:\n' +
-            '     pip3 install utim-cli\n'
-        );
-    }
-    // Exit 0 — don't break the npm install; user can manually pip install
+const python = findPython();
+if (!python) {
+    // No Python — launcher will guide the user on first run
     process.exit(0);
 }
+
+// Silently pre-install in the background (pipe output, not inherit)
+// so the npm install output stays clean. Any failure is fine —
+// the launcher self-heals on first `utim` run.
+try {
+    const r = spawnSync(
+        python,
+        ['-m', 'pip', 'install', '--upgrade', '--quiet', 'utim-cli'],
+        {
+            stdio: 'pipe',
+            shell: isWin,
+            windowsHide: true,
+            timeout: 300000,
+        }
+    );
+    if (r.status === 0) {
+        console.log('\n✅  UTIM ready. Run  utim  to get started.\n');
+    }
+    // If it fails, stay silent — launcher will handle it
+} catch (_) {}
+
+process.exit(0);