@xai-official/grok 1.0.13 → 1.0.14

package/bin/grok

@@ -1,149 +1,4 @@
 #!/usr/bin/env node
-// Thin trampoline: resolves the grok binary and execs it.
-//
-// Resolution order:
-//   1. $GROK_HOME/bin/grok — canonical versioned symlink (installed by postinstall.js)
-//   2. bootstrap it from the per-platform @xai-official/grok-<platform> package,
-//      decompressing the brotli payload straight into $GROK_HOME/bin
-//   3. last resort (no resolvable version or an unwritable home): decompress the
-//      payload in place under node_modules and exec that
-//
-// Per-platform binaries ship brotli-compressed to stay under npm's ~200 MB
-// tarball ceiling. See sibling packages @xai-official/grok-*.
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const zlib = require('zlib');
-
-const pkgName = '@xai-official/grok';
-const IS_WINDOWS = process.platform === 'win32';
-const EXE = IS_WINDOWS ? '.exe' : '';
-const BIN_NAME = `grok${EXE}`;
-// $GROK_HOME/bin (else ~/.grok/bin), matching the Rust grok_home(), including
-// its canonicalized-home default (so a symlinked $HOME resolves the same way).
-function defaultGrokHome() {
-    const home = os.homedir();
-    try { return path.join(fs.realpathSync(home), '.grok'); } catch { return path.join(home, '.grok'); }
-}
-const GROK_HOME = process.env.GROK_HOME ?? defaultGrokHome();
-const CANONICAL_DIR = path.join(GROK_HOME, 'bin');
-const CANONICAL_PATH = path.join(CANONICAL_DIR, BIN_NAME);
-
-function readLocalVersion() {
-    try { return require('../package.json').version; } catch { return undefined; }
-}
-
-// Resolve the per-platform sibling package's directory. Returns null if the
-// matching optional dependency wasn't installed (unsupported platform, or
-// npm refused to install optionalDependencies).
-function resolvePlatformPackageDir() {
-    const platformPkg = `@xai-official/grok-${process.platform}-${process.arch}`;
-    try {
-        return path.dirname(require.resolve(`${platformPkg}/package.json`));
-    } catch {
-        return null;
-    }
-}
-
-function writeVendorBinary(brPath, rawPath, destPath) {
-    const tmp = destPath + `.tmp.${process.pid}`;
-    try {
-        if (fs.existsSync(brPath)) {
-            fs.writeFileSync(tmp, zlib.brotliDecompressSync(fs.readFileSync(brPath)));
-        } else if (fs.existsSync(rawPath)) {
-            fs.copyFileSync(rawPath, tmp);
-        } else {
-            return false;
-        }
-        if (!IS_WINDOWS) fs.chmodSync(tmp, 0o755);
-        fs.renameSync(tmp, destPath);
-        return true;
-    } catch {
-        return false;
-    } finally {
-        try { fs.unlinkSync(tmp); } catch {}
-    }
-}
-
-function swapCanonical(versionedName, versionedPath) {
-    if (!IS_WINDOWS) {
-        const tmpLink = CANONICAL_PATH + `.link.${process.pid}`;
-        try { fs.unlinkSync(tmpLink); } catch {}
-        fs.symlinkSync(versionedName, tmpLink);
-        fs.renameSync(tmpLink, CANONICAL_PATH);
-        return;
-    }
-    const oldPath = CANONICAL_PATH + '.old';
-    try { fs.unlinkSync(oldPath); } catch {}
-    try {
-        try { fs.unlinkSync(CANONICAL_PATH); } catch {}
-        fs.copyFileSync(versionedPath, CANONICAL_PATH);
-    } catch {
-        fs.renameSync(CANONICAL_PATH, oldPath);
-        try {
-            fs.copyFileSync(versionedPath, CANONICAL_PATH);
-        } catch {
-            try { fs.renameSync(oldPath, CANONICAL_PATH); } catch {}
-            throw new Error('locked');
-        }
-    }
-}
-
-function bootstrapCanonical(brPath, rawPath, version) {
-    try {
-        fs.mkdirSync(CANONICAL_DIR, { recursive: true });
-        const versionedName = `grok-${version}${EXE}`;
-        const versionedPath = path.join(CANONICAL_DIR, versionedName);
-        if (!fs.existsSync(versionedPath) && !writeVendorBinary(brPath, rawPath, versionedPath)) {
-            return null;
-        }
-        swapCanonical(versionedName, versionedPath);
-        // null on a broken wire-up so the caller falls back to in-place launch.
-        return fs.existsSync(CANONICAL_PATH) ? CANONICAL_PATH : null;
-    } catch {
-        return null;
-    }
-}
-
-function resolveBinary() {
-    if (fs.existsSync(CANONICAL_PATH)) return CANONICAL_PATH;
-
-    const platformDir = resolvePlatformPackageDir();
-    if (!platformDir) {
-        console.error(`${pkgName}: no platform binary installed for ${process.platform}-${process.arch}.`);
-        console.error(`  Expected sibling package @xai-official/grok-${process.platform}-${process.arch}.`);
-        console.error(`  This usually means npm skipped optionalDependencies (e.g. --no-optional)`);
-        console.error(`  or the platform is not supported.`);
-        process.exit(1);
-    }
-
-    const rawPath = path.join(platformDir, 'bin', BIN_NAME);
-    const brPath = rawPath + '.br';
-    const version = readLocalVersion();
-
-    // Prefer the canonical layout, decompressing straight into CANONICAL_DIR so
-    // no second uncompressed copy lands under node_modules.
-    if (version) {
-        const bootstrapped = bootstrapCanonical(brPath, rawPath, version);
-        if (bootstrapped) return bootstrapped;
-    }
-
-    // Fallback (unresolved version or unwritable home): materialize in place.
-    if (!fs.existsSync(rawPath) && !writeVendorBinary(brPath, rawPath, rawPath)) {
-        console.error(`${pkgName}: missing binary at ${rawPath}`);
-        process.exit(1);
-    }
-    return rawPath;
-}
-
-const execPath = resolveBinary();
-const childEnv = { ...process.env, GROK_MANAGED_BY_NPM: '1' };
-const child = spawn(execPath, process.argv.slice(2), { stdio: 'inherit', env: childEnv });
-child.on('exit', (code, signal) => {
-    if (signal) {
-        process.kill(process.pid, signal);
-    } else {
-        process.exit(code ?? 0);
-    }
-});
+// On Unix npm installs, postinstall.js replaces this entry with a symlink to
+// the sibling grok-native binary; every other install launches through node.
+require('./grok-bootstrap.js');

package/bin/grok-bootstrap.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+// Resolves the grok binary and runs it, in order of preference:
+//   1. $GROK_HOME/bin/grok, the versioned symlink postinstall.js installs
+//   2. bootstrap it from the per-platform @xai-official/grok-<platform>
+//      package, decompressing the compressed binary into $GROK_HOME/bin
+//   3. decompress in place under node_modules (no resolvable version, or
+//      an unwritable home)
+//
+// Binaries ship brotli-compressed to stay under npm's tarball size limit.
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const zlib = require('zlib');
+
+const pkgName = '@xai-official/grok';
+const IS_WINDOWS = process.platform === 'win32';
+const EXE = IS_WINDOWS ? '.exe' : '';
+const BIN_NAME = `grok${EXE}`;
+// $GROK_HOME/bin (else ~/.grok/bin), matching the Rust grok_home():
+// a symlinked $HOME resolves the same way.
+function defaultGrokHome() {
+    const home = os.homedir();
+    try { return path.join(fs.realpathSync(home), '.grok'); } catch { return path.join(home, '.grok'); }
+}
+const GROK_HOME = process.env.GROK_HOME ?? defaultGrokHome();
+const CANONICAL_DIR = path.join(GROK_HOME, 'bin');
+const CANONICAL_PATH = path.join(CANONICAL_DIR, BIN_NAME);
+
+function readLocalVersion() {
+    try { return require('../package.json').version; } catch { return undefined; }
+}
+
+// Returns null when npm skipped the matching optional dependency
+// (unsupported platform, or --no-optional).
+function resolvePlatformPackageDir() {
+    const platformPkg = `@xai-official/grok-${process.platform}-${process.arch}`;
+    try {
+        return path.dirname(require.resolve(`${platformPkg}/package.json`));
+    } catch {
+        return null;
+    }
+}
+
+function writeVendorBinary(brotliPath, binaryPath, destPath) {
+    const tmp = destPath + `.tmp.${process.pid}`;
+    try {
+        if (fs.existsSync(brotliPath)) {
+            fs.writeFileSync(tmp, zlib.brotliDecompressSync(fs.readFileSync(brotliPath)));
+        } else if (fs.existsSync(binaryPath)) {
+            fs.copyFileSync(binaryPath, tmp);
+        } else {
+            return false;
+        }
+        if (!IS_WINDOWS) fs.chmodSync(tmp, 0o755);
+        fs.renameSync(tmp, destPath);
+        return true;
+    } catch {
+        return false;
+    } finally {
+        try { fs.unlinkSync(tmp); } catch {}
+    }
+}
+
+function swapCanonical(versionedName, versionedPath) {
+    if (!IS_WINDOWS) {
+        const tmpLink = CANONICAL_PATH + `.link.${process.pid}`;
+        try { fs.unlinkSync(tmpLink); } catch {}
+        fs.symlinkSync(versionedName, tmpLink);
+        fs.renameSync(tmpLink, CANONICAL_PATH);
+        return;
+    }
+    const oldPath = CANONICAL_PATH + '.old';
+    try { fs.unlinkSync(oldPath); } catch {}
+    try {
+        try { fs.unlinkSync(CANONICAL_PATH); } catch {}
+        fs.copyFileSync(versionedPath, CANONICAL_PATH);
+    } catch {
+        fs.renameSync(CANONICAL_PATH, oldPath);
+        try {
+            fs.copyFileSync(versionedPath, CANONICAL_PATH);
+        } catch {
+            try { fs.renameSync(oldPath, CANONICAL_PATH); } catch {}
+            throw new Error('locked');
+        }
+    }
+}
+
+function bootstrapCanonical(brotliPath, binaryPath, version) {
+    try {
+        fs.mkdirSync(CANONICAL_DIR, { recursive: true });
+        const versionedName = `grok-${version}${EXE}`;
+        const versionedPath = path.join(CANONICAL_DIR, versionedName);
+        if (!fs.existsSync(versionedPath) && !writeVendorBinary(brotliPath, binaryPath, versionedPath)) {
+            return null;
+        }
+        swapCanonical(versionedName, versionedPath);
+        // null on a broken wire-up so the caller falls back to in-place launch.
+        return fs.existsSync(CANONICAL_PATH) ? CANONICAL_PATH : null;
+    } catch {
+        return null;
+    }
+}
+
+function resolveBinary() {
+    if (fs.existsSync(CANONICAL_PATH)) return CANONICAL_PATH;
+
+    const platformDir = resolvePlatformPackageDir();
+    if (!platformDir) {
+        console.error(`${pkgName}: no platform binary installed for ${process.platform}-${process.arch}.`);
+        console.error(`  Expected sibling package @xai-official/grok-${process.platform}-${process.arch}.`);
+        console.error(`  This usually means npm skipped optionalDependencies (e.g. --no-optional)`);
+        console.error(`  or the platform is not supported.`);
+        process.exit(1);
+    }
+
+    const binaryPath = path.join(platformDir, 'bin', BIN_NAME);
+    const brotliPath = binaryPath + '.br';
+    const version = readLocalVersion();
+
+    if (version) {
+        const bootstrapped = bootstrapCanonical(brotliPath, binaryPath, version);
+        if (bootstrapped) return bootstrapped;
+    }
+
+    if (!fs.existsSync(binaryPath) && !writeVendorBinary(brotliPath, binaryPath, binaryPath)) {
+        console.error(`${pkgName}: missing binary at ${binaryPath}`);
+        process.exit(1);
+    }
+    return binaryPath;
+}
+
+const execPath = resolveBinary();
+const childEnv = { ...process.env, GROK_MANAGED_BY_NPM: '1' };
+const child = spawn(execPath, process.argv.slice(2), { stdio: 'inherit', env: childEnv });
+child.on('exit', (code, signal) => {
+    if (signal) {
+        process.kill(process.pid, signal);
+    } else {
+        process.exit(code ?? 0);
+    }
+});

package/bin/postinstall.js

@@ -16,8 +16,8 @@ const zlib = require('zlib');
 const { execSync } = require('child_process');
 const TOML = require('@iarna/toml');
 
-// $GROK_HOME (else ~/.grok), matching the Rust grok_home() including its
-// canonicalized-home default. Lets fleets relocate the binary off a slow $HOME
+// $GROK_HOME (else ~/.grok), matching the Rust grok_home(): a symlinked
+// $HOME resolves the same way. Lets fleets relocate the binary off a slow $HOME
 // (NFS); old code hardcoded os.homedir().
 function defaultGrokHome() {
     const home = os.homedir();
@@ -65,13 +65,13 @@ const EXE = IS_WINDOWS ? '.exe' : '';
 
 fs.mkdirSync(CANONICAL_DIR, { recursive: true });
 
-function writeVendorBinary(brPath, rawPath, destPath) {
+function writeVendorBinary(brotliPath, binaryPath, destPath) {
     const tmp = destPath + `.tmp.${process.pid}`;
     try {
-        if (fs.existsSync(brPath)) {
-            fs.writeFileSync(tmp, zlib.brotliDecompressSync(fs.readFileSync(brPath)));
-        } else if (fs.existsSync(rawPath)) {
-            fs.copyFileSync(rawPath, tmp);
+        if (fs.existsSync(brotliPath)) {
+            fs.writeFileSync(tmp, zlib.brotliDecompressSync(fs.readFileSync(brotliPath)));
+        } else if (fs.existsSync(binaryPath)) {
+            fs.copyFileSync(binaryPath, tmp);
         } else {
             return false;
         }
@@ -86,8 +86,8 @@ function writeVendorBinary(brPath, rawPath, destPath) {
 }
 
 function installBinary(binName, sourceDir, vendorSubpath) {
-    const brPath = path.join(sourceDir, 'bin', vendorSubpath + '.br');
-    const rawPath = path.join(sourceDir, 'bin', vendorSubpath);
+    const brotliPath = path.join(sourceDir, 'bin', vendorSubpath + '.br');
+    const binaryPath = path.join(sourceDir, 'bin', vendorSubpath);
 
     const versionedName = `${binName}-${version}${EXE}`;
     const versionedPath = path.join(CANONICAL_DIR, versionedName);
@@ -95,8 +95,8 @@ function installBinary(binName, sourceDir, vendorSubpath) {
     const canonicalPath = path.join(CANONICAL_DIR, canonicalName);
 
     // Skip if this exact version is already installed.
-    if (!fs.existsSync(versionedPath) && !writeVendorBinary(brPath, rawPath, versionedPath)) {
-        console.error(`@xai-official/grok: missing binary at ${brPath}`);
+    if (!fs.existsSync(versionedPath) && !writeVendorBinary(brotliPath, binaryPath, versionedPath)) {
+        console.error(`@xai-official/grok: missing binary at ${brotliPath}`);
         return false;
     }
 
@@ -186,7 +186,35 @@ if (!platformDir) {
     process.exit(0);
 }
 
-installBinary('grok', platformDir, `grok${EXE}`);
+// Point the bin entry at a binary extracted beside it: launches become one
+// process, and the link can only dangle if the package itself is broken.
+// Windows keeps the node launcher; npm generates its command shims from it.
+function installBinLink(platformDir) {
+    if (IS_WINDOWS) return;
+    // Other package managers wrap the entry's `#!` line in their own launchers.
+    if (!(process.env.npm_config_user_agent ?? '').startsWith('npm/')) return;
+    const brotliPath = path.join(platformDir, 'bin', `grok${EXE}.br`);
+    const binaryPath = path.join(platformDir, 'bin', `grok${EXE}`);
+    const nativePath = path.join(__dirname, 'grok-native');
+    const entryPath = path.join(__dirname, 'grok');
+    const tmp = entryPath + `.link.${process.pid}`;
+    try {
+        if (!writeVendorBinary(brotliPath, binaryPath, nativePath)) {
+            return;
+        }
+        try { fs.unlinkSync(tmp); } catch {}
+        fs.symlinkSync('./grok-native', tmp);
+        fs.renameSync(tmp, entryPath);
+    } catch (e) {
+        // Losing the link only costs latency; the node launcher still works.
+        console.error(`@xai-official/grok: bin link not installed: ${e.message}`);
+        try { fs.unlinkSync(tmp); } catch {}
+    }
+}
+
+if (installBinary('grok', platformDir, `grok${EXE}`)) {
+    installBinLink(platformDir);
+}
 cleanupOldVersions('grok');
 cleanupOldVersions('grok-pager');
 
@@ -198,7 +226,7 @@ try { obj = TOML.parse(fs.readFileSync(configPath, 'utf8')); } catch { }
 obj.cli ??= {};
 obj.cli.installer = 'npm';
 
-// Persist the npm registry so `grok update` and the trampoline use the same one.
+// Persist the npm registry so `grok update` and the launcher use the same one.
 const npmRegistry = process.env.GROK_NPM_REGISTRY
     || (() => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xai-official/grok",
-    "version": "1.0.13",
+    "version": "1.0.14",
     "description": "Bring Grok into your terminal",
     "license": "Apache-2.0",
     "bin": {
@@ -31,11 +31,11 @@
         "@iarna/toml": "^3.0.0"
     },
     "optionalDependencies": {
-        "@xai-official/grok-darwin-arm64": "1.0.13",
-        "@xai-official/grok-darwin-x64": "1.0.13",
-        "@xai-official/grok-linux-arm64": "1.0.13",
-        "@xai-official/grok-linux-x64": "1.0.13",
-        "@xai-official/grok-win32-arm64": "1.0.13",
-        "@xai-official/grok-win32-x64": "1.0.13"
+        "@xai-official/grok-darwin-arm64": "1.0.14",
+        "@xai-official/grok-darwin-x64": "1.0.14",
+        "@xai-official/grok-linux-arm64": "1.0.14",
+        "@xai-official/grok-linux-x64": "1.0.14",
+        "@xai-official/grok-win32-arm64": "1.0.14",
+        "@xai-official/grok-win32-x64": "1.0.14"
     }
 }