@hanzo/dev 3.0.1 → 3.0.2

package/postinstall.js

@@ -1,37 +1,34 @@
 #!/usr/bin/env node
-// Non-functional change to trigger release workflow
+// Postinstall script for @hanzo/dev
 
-import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync, copyFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { existsSync, mkdirSync, createWriteStream, chmodSync, readFileSync, readSync, writeFileSync, unlinkSync, statSync, openSync, closeSync, copyFileSync, fsyncSync, renameSync, realpathSync } from 'fs';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { get } from 'https';
-import { platform, arch } from 'os';
+import { platform, arch, tmpdir } from 'os';
 import { execSync } from 'child_process';
 import { createRequire } from 'module';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Map Node.js platform/arch to Rust target triples
 function getTargetTriple() {
   const platformMap = {
     'darwin': 'apple-darwin',
-    'linux': 'unknown-linux-musl',  // Default to musl for better compatibility
+    'linux': 'unknown-linux-musl',
     'win32': 'pc-windows-msvc'
   };
-  
+
   const archMap = {
     'x64': 'x86_64',
     'arm64': 'aarch64'
   };
-  
+
   const rustArch = archMap[arch()] || arch();
   const rustPlatform = platformMap[platform()] || platform();
-  
+
   return `${rustArch}-${rustPlatform}`;
 }
 
-// Resolve a persistent user cache directory for binaries so that repeated
-// npx installs can reuse a previously downloaded artifact and skip work.
 function getCacheDir(version) {
   const plt = platform();
   const home = process.env.HOME || process.env.USERPROFILE || '';
@@ -43,7 +40,7 @@ function getCacheDir(version) {
   } else {
     base = process.env.XDG_CACHE_HOME || join(home, '.cache');
   }
-  const dir = join(base, 'just-every', 'code', version);
+  const dir = join(base, 'hanzo', 'dev', version);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -51,7 +48,99 @@ function getCacheDir(version) {
 function getCachedBinaryPath(version, targetTriple, isWindows) {
   const ext = isWindows ? '.exe' : '';
   const cacheDir = getCacheDir(version);
-  return join(cacheDir, `code-${targetTriple}${ext}`);
+  return join(cacheDir, `dev-${targetTriple}${ext}`);
+}
+
+function isWSL() {
+  if (platform() !== 'linux') return false;
+  try {
+    const ver = readFileSync('/proc/version', 'utf8').toLowerCase();
+    return ver.includes('microsoft') || !!process.env.WSL_DISTRO_NAME;
+  } catch { return false; }
+}
+
+function isPathOnWindowsFs(p) {
+  try {
+    const mounts = readFileSync('/proc/mounts', 'utf8').split(/\n/).filter(Boolean);
+    let best = { mount: '/', type: 'unknown', len: 1 };
+    for (const line of mounts) {
+      const parts = line.split(' ');
+      if (parts.length < 3) continue;
+      const mnt = parts[1];
+      const typ = parts[2];
+      if (p.startsWith(mnt) && mnt.length > best.len) best = { mount: mnt, type: typ, len: mnt.length };
+    }
+    return best.type === 'drvfs' || best.type === 'cifs';
+  } catch { return false; }
+}
+
+async function writeCacheAtomic(srcPath, cachePath) {
+  try {
+    if (existsSync(cachePath)) {
+      const ok = validateDownloadedBinary(cachePath).ok;
+      if (ok) return;
+    }
+  } catch {}
+  const dir = dirname(cachePath);
+  if (!existsSync(dir)) { try { mkdirSync(dir, { recursive: true }); } catch {} }
+  const tmp = cachePath + '.tmp-' + Math.random().toString(36).slice(2, 8);
+  copyFileSync(srcPath, tmp);
+  try { const fd = openSync(tmp, 'r'); try { fsyncSync(fd); } finally { closeSync(fd); } } catch {}
+  const delays = [100, 200, 400, 800, 1200, 1600];
+  for (let i = 0; i < delays.length; i++) {
+    try {
+      if (existsSync(cachePath)) { try { unlinkSync(cachePath); } catch {} }
+      renameSync(tmp, cachePath);
+      return;
+    } catch {
+      await new Promise(r => setTimeout(r, delays[i]));
+    }
+  }
+  if (existsSync(cachePath)) { try { unlinkSync(cachePath); } catch {} }
+  renameSync(tmp, cachePath);
+}
+
+function resolveGlobalBinDir() {
+  const plt = platform();
+  const userAgent = process.env.npm_config_user_agent || '';
+
+  const fromPrefix = (prefixPath) => {
+    if (!prefixPath) return '';
+    return plt === 'win32' ? prefixPath : join(prefixPath, 'bin');
+  };
+
+  const prefixEnv = process.env.npm_config_prefix || process.env.PREFIX || '';
+  const direct = fromPrefix(prefixEnv);
+  if (direct) return direct;
+
+  const tryExec = (command) => {
+    try {
+      return execSync(command, {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        shell: true,
+      }).toString().trim();
+    } catch {
+      return '';
+    }
+  };
+
+  const prefixFromNpm = fromPrefix(tryExec('npm prefix -g'));
+  if (prefixFromNpm) return prefixFromNpm;
+
+  const binFromNpm = tryExec('npm bin -g');
+  if (binFromNpm) return binFromNpm;
+
+  if (userAgent.includes('pnpm')) {
+    const pnpmBin = tryExec('pnpm bin --global');
+    if (pnpmBin) return pnpmBin;
+  }
+
+  if (userAgent.includes('yarn')) {
+    const yarnBin = tryExec('yarn global bin');
+    if (yarnBin) return yarnBin;
+  }
+
+  return '';
 }
 
 async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
@@ -76,7 +165,7 @@ async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
           const expected = parseInt(response.headers['content-length'] || '0', 10) || 0;
           let bytes = 0;
           let timer;
-          const timeoutMs = 30000; // 30s inactivity timeout
+          const timeoutMs = 30000;
 
           const resetTimer = () => {
             if (timer) clearTimeout(timer);
@@ -121,7 +210,6 @@ async function downloadBinary(url, dest, maxRedirects = 5, maxRetries = 3) {
         reject(err);
       });
 
-      // Absolute request timeout to avoid hanging forever
       req.setTimeout(120000, () => {
         req.destroy(new Error('download timed out'));
       });
@@ -173,102 +261,74 @@ function validateDownloadedBinary(p) {
   }
 }
 
-async function main() {
-  // Detect potential PATH conflict with an existing `code` command (e.g., VS Code)
-  // Only relevant for global installs; skip for npx/local installs to keep postinstall fast.
+export async function runPostinstall(options = {}) {
+  const { skipGlobalAlias = false, invokedByRuntime = false } = options;
+  if (process.env.DEV_POSTINSTALL_DRY_RUN === '1') {
+    return { skipped: true };
+  }
+
+  if (invokedByRuntime) {
+    process.env.DEV_RUNTIME_POSTINSTALL = process.env.DEV_RUNTIME_POSTINSTALL || '1';
+  }
+
   const ua = process.env.npm_config_user_agent || '';
   const isNpx = ua.includes('npx');
   const isGlobal = process.env.npm_config_global === 'true';
-  if (isGlobal && !isNpx) {
-    try {
-      const whichCmd = process.platform === 'win32' ? 'where code' : 'command -v code || which code || true';
-      const resolved = execSync(whichCmd, { stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform !== 'win32' }).toString().split(/\r?\n/).filter(Boolean)[0];
-      if (resolved) {
-        let contents = '';
-        try {
-          contents = readFileSync(resolved, 'utf8');
-        } catch {
-          contents = '';
-        }
-        const looksLikeOurs = contents.includes('@just-every/code') || contents.includes('bin/coder.js');
-        if (!looksLikeOurs) {
-          console.warn('[notice] Found an existing `code` on PATH at:');
-          console.warn(`         ${resolved}`);
-          console.warn('[notice] We will still install our CLI, also available as `coder`.');
-          console.warn('         If `code` runs another tool, prefer using: coder');
-          console.warn('         Or run our CLI explicitly via: npx -y @just-every/code');
-        }
-      }
-    } catch {
-      // Ignore detection failures; proceed with install.
-    }
-  }
 
   const targetTriple = getTargetTriple();
   const isWindows = platform() === 'win32';
   const binaryExt = isWindows ? '.exe' : '';
-  
+
   const binDir = join(__dirname, 'bin');
   if (!existsSync(binDir)) {
     mkdirSync(binDir, { recursive: true });
   }
-  
-  // Get package version - use readFileSync for compatibility
+
   const packageJson = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8'));
   const version = packageJson.version;
-  
-  // Download only the primary binary; we'll create wrappers for legacy names.
+
+  // The release produces 'code-*' binaries; we'll download and rename to 'dev-*'
   const binaries = ['code'];
-  
-  console.log(`Installing @just-every/code v${version} for ${targetTriple}...`);
-  
+
+  console.log(`Installing @hanzo/dev v${version} for ${targetTriple}...`);
+
   for (const binary of binaries) {
     const binaryName = `${binary}-${targetTriple}${binaryExt}`;
-    const localPath = join(binDir, binaryName);
+    const devBinaryName = `dev-${targetTriple}${binaryExt}`;
+    const localPath = join(binDir, devBinaryName);
     const cachePath = getCachedBinaryPath(version, targetTriple, isWindows);
-    
-    // Skip if already exists and has correct permissions
-    if (existsSync(localPath)) {
-      // Always try to fix permissions on Unix-like systems
-      if (!isWindows) {
-        try {
-          chmodSync(localPath, 0o755);
-          console.log(`✓ ${binaryName} already exists (permissions fixed)`);
-        } catch (e) {
-          console.log(`✓ ${binaryName} already exists`);
-        }
-      } else {
-        console.log(`✓ ${binaryName} already exists`);
-      }
-      continue;
-    }
 
-    // Fast path: if a valid cached binary exists for this version+triple, reuse it.
+    // Fast path: if a valid cached binary exists, reuse it
     try {
       if (existsSync(cachePath)) {
         const valid = validateDownloadedBinary(cachePath);
         if (valid.ok) {
-          copyFileSync(cachePath, localPath);
-          if (!isWindows) chmodSync(localPath, 0o755);
-          console.log(`✓ Installed ${binaryName} from user cache`);
-          continue; // next binary
+          const wsl = isWSL();
+          const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
+          const mirrorToLocal = !(isWindows || (wsl && isPathOnWindowsFs(binDirReal)));
+          if (mirrorToLocal) {
+            copyFileSync(cachePath, localPath);
+            try { chmodSync(localPath, 0o755); } catch {}
+          }
+          console.log(`✓ ${devBinaryName} ready from user cache`);
+          continue;
         }
       }
     } catch {
-      // Ignore cache errors and fall through to normal paths
+      // Ignore cache errors
     }
-    
-    // First try platform package via npm optionalDependencies (fast path on npm CDN).
+
+    // Try platform package via npm optionalDependencies
     const require = createRequire(import.meta.url);
     const platformPkg = (() => {
       const name = (() => {
-        if (isWindows) return '@just-every/code-win32-x64';
+        if (isWindows) return '@hanzo/dev-win32-x64';
         const plt = platform();
         const cpu = arch();
-        if (plt === 'darwin' && cpu === 'arm64') return '@just-every/code-darwin-arm64';
-        if (plt === 'darwin' && cpu === 'x64') return '@just-every/code-darwin-x64';
-        if (plt === 'linux' && cpu === 'x64') return '@just-every/code-linux-x64-musl';
-        if (plt === 'linux' && cpu === 'arm64') return '@just-every/code-linux-arm64-musl';
+        if (plt === 'darwin' && cpu === 'arm64') return '@hanzo/dev-darwin-arm64';
+        if (plt === 'darwin' && cpu === 'x64') return '@hanzo/dev-darwin-x64';
+        if (plt === 'linux' && cpu === 'x64') return '@hanzo/dev-linux-x64-musl';
+        if (plt === 'linux' && cpu === 'arm64') return '@hanzo/dev-linux-arm64-musl';
         return null;
       })();
       if (!name) return null;
@@ -283,30 +343,30 @@ async function main() {
 
     if (platformPkg) {
       try {
-        // Expect binary inside platform package bin directory
-        const src = join(platformPkg.dir, 'bin', binaryName);
+        const src = join(platformPkg.dir, 'bin', devBinaryName);
         if (!existsSync(src)) {
           throw new Error(`platform package missing binary: ${platformPkg.name}`);
         }
-        copyFileSync(src, localPath);
-        if (!isWindows) chmodSync(localPath, 0o755);
-        console.log(`✓ Installed ${binaryName} from ${platformPkg.name}`);
-        // Populate cache for future npx runs
-        try {
-          if (!existsSync(cachePath)) {
-            copyFileSync(localPath, cachePath);
-          }
-        } catch {}
-        continue; // next binary
+        await writeCacheAtomic(src, cachePath);
+        const wsl = isWSL();
+        const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
+        const mirrorToLocal = !(isWindows || (wsl && isPathOnWindowsFs(binDirReal)));
+        if (mirrorToLocal) {
+          copyFileSync(cachePath, localPath);
+          try { chmodSync(localPath, 0o755); } catch {}
+        }
+        console.log(`✓ Installed ${devBinaryName} from ${platformPkg.name} (cached)`);
+        continue;
       } catch (e) {
         console.warn(`⚠ Failed platform package install (${e.message}), falling back to GitHub download`);
       }
     }
 
-    // Decide archive format per OS with fallback on macOS/Linux:
-    // - Windows: .zip
-    // - macOS/Linux: prefer .zst if `zstd` CLI is available; otherwise use .tar.gz
+    // Download from GitHub release
     const isWin = isWindows;
+    const detectedWSL = isWSL();
+    const binDirReal = (() => { try { return realpathSync(binDir); } catch { return binDir; } })();
+    const mirrorToLocal = !(isWin || (detectedWSL && isPathOnWindowsFs(binDirReal)));
     let useZst = false;
     if (!isWin) {
       try {
@@ -317,35 +377,61 @@ async function main() {
       }
     }
     const archiveName = isWin ? `${binaryName}.zip` : (useZst ? `${binaryName}.zst` : `${binaryName}.tar.gz`);
-    const downloadUrl = `https://github.com/just-every/code/releases/download/v${version}/${archiveName}`;
+    const downloadUrl = `https://github.com/hanzoai/dev/releases/download/v${version}/${archiveName}`;
 
     console.log(`Downloading ${archiveName}...`);
     try {
-      const tmpPath = join(binDir, `.${archiveName}.part`);
+      const needsIsolation = isWin || (!isWin && !mirrorToLocal);
+      let safeTempDir = needsIsolation ? join(tmpdir(), 'hanzo', 'dev', version) : binDir;
+      if (needsIsolation) {
+        try {
+          if (!existsSync(safeTempDir)) mkdirSync(safeTempDir, { recursive: true });
+        } catch {
+          try {
+            safeTempDir = getCacheDir(version);
+            if (!existsSync(safeTempDir)) mkdirSync(safeTempDir, { recursive: true });
+          } catch {}
+        }
+      }
+      const tmpPath = join(needsIsolation ? safeTempDir : binDir, `.${archiveName}.part`);
       await downloadBinary(downloadUrl, tmpPath);
 
       if (isWin) {
-        // Unzip the single-file archive using PowerShell (built-in)
+        const unzipDest = safeTempDir;
         try {
-          const psCmd = `powershell -NoProfile -NonInteractive -Command "Expand-Archive -Path '${tmpPath}' -DestinationPath '${binDir}' -Force"`;
-          execSync(psCmd, { stdio: 'ignore' });
+          const sysRoot = process.env.SystemRoot || process.env.windir || 'C:\\Windows';
+          const psFull = join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+          const psCmd = `Expand-Archive -Path '${tmpPath}' -DestinationPath '${unzipDest}' -Force`;
+          let ok = false;
+          try { execSync(`"${psFull}" -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {}
+          if (!ok) { try { execSync(`powershell -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+          if (!ok) { try { execSync(`pwsh -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: 'ignore' }); ok = true; } catch {} }
+          if (!ok) { execSync(`tar -xf "${tmpPath}" -C "${unzipDest}"`, { stdio: 'ignore', shell: true }); }
         } catch (e) {
           throw new Error(`failed to unzip archive: ${e.message}`);
         } finally {
           try { unlinkSync(tmpPath); } catch {}
         }
+        try {
+          const extractedPath = join(unzipDest, binaryName);
+          // Rename code-* to dev-* in cache
+          const devCachePath = cachePath;
+          await writeCacheAtomic(extractedPath, devCachePath);
+          try { unlinkSync(extractedPath); } catch {}
+        } catch (e) {
+          throw new Error(`failed to move binary to cache: ${e.message}`);
+        }
       } else {
+        const downloadedPath = join(binDir, binaryName);
         if (useZst) {
-          // Decompress .zst via system zstd
           try {
-            execSync(`zstd -d '${tmpPath}' -o '${localPath}'`, { stdio: 'ignore', shell: true });
+            execSync(`zstd -d '${tmpPath}' -o '${downloadedPath}'`, { stdio: 'ignore', shell: true });
           } catch (e) {
             try { unlinkSync(tmpPath); } catch {}
             throw new Error(`failed to decompress .zst (need zstd CLI): ${e.message}`);
           }
           try { unlinkSync(tmpPath); } catch {}
         } else {
-          // Extract .tar.gz using system tar
           try {
             execSync(`tar -xzf '${tmpPath}' -C '${binDir}'`, { stdio: 'ignore', shell: true });
           } catch (e) {
@@ -354,43 +440,47 @@ async function main() {
           }
           try { unlinkSync(tmpPath); } catch {}
         }
+        // Rename code-* to dev-*
+        if (existsSync(downloadedPath)) {
+          if (mirrorToLocal) {
+            renameSync(downloadedPath, localPath);
+          } else {
+            const extractedPath = downloadedPath;
+            await writeCacheAtomic(extractedPath, cachePath);
+            try { unlinkSync(extractedPath); } catch {}
+          }
+        }
       }
 
-      // Validate header to avoid corrupt binaries causing spawn EFTYPE/ENOEXEC
-      const valid = validateDownloadedBinary(localPath);
+      const valid = validateDownloadedBinary(isWin ? cachePath : (mirrorToLocal ? localPath : cachePath));
       if (!valid.ok) {
-        try { unlinkSync(localPath); } catch {}
+        try { (isWin || !mirrorToLocal) ? unlinkSync(cachePath) : unlinkSync(localPath); } catch {}
         throw new Error(`invalid binary (${valid.reason})`);
       }
 
-      // Make executable on Unix-like systems
-      if (!isWindows) {
+      if (!isWin && mirrorToLocal) {
         chmodSync(localPath, 0o755);
       }
-      
-      console.log(`✓ Installed ${binaryName}`);
-      // Save into persistent cache for future fast installs
-      try {
-        copyFileSync(localPath, cachePath);
-      } catch {}
+
+      console.log(`✓ Installed ${devBinaryName}${(isWin || !mirrorToLocal) ? ' (cached)' : ''}`);
+      if (!isWin && mirrorToLocal) {
+        try { await writeCacheAtomic(localPath, cachePath); } catch {}
+      }
     } catch (error) {
-      console.error(`✗ Failed to install ${binaryName}: ${error.message}`);
+      console.error(`✗ Failed to install ${devBinaryName}: ${error.message}`);
       console.error(`  Downloaded from: ${downloadUrl}`);
-      // Continue with other binaries even if one fails
     }
   }
 
-  // Create platform-specific symlink/copy for main binary
-  const mainBinary = `code-${targetTriple}${binaryExt}`;
+  const mainBinary = `dev-${targetTriple}${binaryExt}`;
   const mainBinaryPath = join(binDir, mainBinary);
-  
-  if (existsSync(mainBinaryPath)) {
+
+  if (existsSync(mainBinaryPath) || existsSync(getCachedBinaryPath(version, targetTriple, platform() === 'win32'))) {
     try {
-      const stats = statSync(mainBinaryPath);
-      if (!stats.size) {
-        throw new Error('binary is empty (download likely failed)');
-      }
-      const valid = validateDownloadedBinary(mainBinaryPath);
+      const probePath = existsSync(mainBinaryPath) ? mainBinaryPath : getCachedBinaryPath(version, targetTriple, platform() === 'win32');
+      const stats = statSync(probePath);
+      if (!stats.size) throw new Error('binary is empty (download likely failed)');
+      const valid = validateDownloadedBinary(probePath);
       if (!valid.ok) {
         console.warn(`⚠ Main dev binary appears invalid: ${valid.reason}`);
         console.warn('  Try reinstalling or check your network/proxy settings.');
@@ -399,191 +489,25 @@ async function main() {
       console.warn(`⚠ Main dev binary appears invalid: ${e.message}`);
       console.warn('  Try reinstalling or check your network/proxy settings.');
     }
-    console.log('Setting up main dev binary...');
-    
-    // On Windows, we can't use symlinks easily, so update the JS wrapper
-    // On Unix, the JS wrapper will find the correct binary
     console.log('✓ Installation complete!');
   } else {
-    console.warn('⚠ Main code binary not found. You may need to build from source.');
+    console.warn('⚠ Main dev binary not found. You may need to build from source.');
   }
+}
 
-  // Handle collisions (e.g., VS Code) and add wrappers. We no longer publish a
-  // `code` bin in package.json. Instead, for global installs we create a `code`
-  // wrapper only when there is no conflicting `code` earlier on PATH. This avoids
-  // hijacking the VS Code CLI while still giving users a friendly name when safe.
-  // For upgrades from older versions that published a `code` bin, we also remove
-  // our old shim if a conflict is detected.
-  if (isGlobal && !isNpx) try {
-    const isTTY = process.stdout && process.stdout.isTTY;
-    const isWindows = platform() === 'win32';
-    const ua = process.env.npm_config_user_agent || '';
-    const isBun = ua.includes('bun') || !!process.env.BUN_INSTALL;
-
-    const installedCmds = new Set(['coder']); // global install always exposes coder via package manager
-    const skippedCmds = [];
-
-    // Helper to resolve all 'code' on PATH
-    const resolveAllOnPath = () => {
-      try {
-        if (isWindows) {
-          const out = execSync('where code', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
-          return out.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-        }
-        let out = '';
-        try {
-          out = execSync('bash -lc "which -a code 2>/dev/null"', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
-        } catch {
-          try {
-            out = execSync('command -v code || true', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
-          } catch { out = ''; }
-        }
-        return out.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-      } catch {
-        return [];
-      }
-    };
-
-    if (isBun) {
-      // Bun creates shims for every bin; if another 'code' exists elsewhere on PATH, remove Bun's shim
-      let bunBin = '';
-      try {
-        const home = process.env.HOME || process.env.USERPROFILE || '';
-        const bunBase = process.env.BUN_INSTALL || join(home, '.bun');
-        bunBin = join(bunBase, 'bin');
-      } catch {}
-
-      const bunShim = join(bunBin || '', isWindows ? 'code.cmd' : 'code');
-      const candidates = resolveAllOnPath();
-      const other = candidates.find(p => p && (!bunBin || !p.startsWith(bunBin)));
-      if (other && existsSync(bunShim)) {
-        try {
-          unlinkSync(bunShim);
-          console.log(`✓ Skipped global 'code' shim under Bun (existing: ${other})`);
-          skippedCmds.push({ name: 'code', reason: `existing: ${other}` });
-        } catch (e) {
-          console.log(`⚠ Could not remove Bun shim '${bunShim}': ${e.message}`);
-        }
-      } else if (!other) {
-        // No conflict: create a wrapper that forwards to `coder`
-        try {
-          const wrapperPath = bunShim;
-          if (isWindows) {
-            const content = `@echo off\r\n"%~dp0coder" %*\r\n`;
-            writeFileSync(wrapperPath, content);
-          } else {
-            const content = `#!/bin/sh\nexec "$(dirname \"$0\")/coder" "$@"\n`;
-            writeFileSync(wrapperPath, content);
-            chmodSync(wrapperPath, 0o755);
-          }
-          console.log("✓ Created 'code' wrapper -> coder (bun)");
-          installedCmds.add('code');
-        } catch (e) {
-          console.log(`⚠ Failed to create 'code' wrapper (bun): ${e.message}`);
-        }
-      }
-
-      // Print summary for Bun
-      const list = Array.from(installedCmds).sort().join(', ');
-      console.log(`Commands installed (bun): ${list}`);
-      if (skippedCmds.length) {
-        for (const s of skippedCmds) console.error(`Commands skipped: ${s.name} (${s.reason})`);
-        console.error('→ Use `coder` to run this tool.');
-      }
-      // Final friendly usage hint
-      if (installedCmds.has('code')) {
-        console.log("Use 'dev' to launch Hanzo Dev.");
-      } else {
-        console.log("Use 'dev' to launch Hanzo Dev.");
-      }
-    } else {
-      // npm/pnpm/yarn path
-      let globalBin = '';
-      try {
-        globalBin = execSync('npm bin -g', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-      } catch {}
-
-      const ourShim = join(globalBin || '', isWindows ? 'code.cmd' : 'code');
-      const candidates = resolveAllOnPath();
-      const others = candidates.filter(p => p && (!ourShim || p !== ourShim));
-      const collision = others.length > 0;
-
-      const ensureWrapper = (name, args) => {
-        if (!globalBin) return;
-        try {
-          const wrapperPath = join(globalBin, isWindows ? `${name}.cmd` : name);
-          if (isWindows) {
-            const content = `@echo off\r\n"%~dp0${collision ? 'coder' : 'code'}" ${args} %*\r\n`;
-            writeFileSync(wrapperPath, content);
-          } else {
-            const content = `#!/bin/sh\nexec "$(dirname \"$0\")/${collision ? 'coder' : 'code'}" ${args} "$@"\n`;
-            writeFileSync(wrapperPath, content);
-            chmodSync(wrapperPath, 0o755);
-          }
-          console.log(`✓ Created wrapper '${name}' -> ${collision ? 'coder' : 'code'} ${args}`);
-          installedCmds.add(name);
-        } catch (e) {
-          console.log(`⚠ Failed to create '${name}' wrapper: ${e.message}`);
-        }
-      };
-
-      // Always create legacy wrappers so existing scripts keep working
-      ensureWrapper('code-tui', '');
-      ensureWrapper('code-exec', 'exec');
-
-      if (collision) {
-        console.error('⚠ Detected existing `code` on PATH:');
-        for (const p of others) console.error(`   - ${p}`);
-        if (globalBin) {
-          try {
-            if (existsSync(ourShim)) {
-              unlinkSync(ourShim);
-              console.error(`✓ Skipped global 'code' shim (removed ${ourShim})`);
-              skippedCmds.push({ name: 'code', reason: `existing: ${others[0]}` });
-            }
-          } catch (e) {
-            console.error(`⚠ Could not remove npm shim '${ourShim}': ${e.message}`);
-          }
-          console.error('→ Use `coder` to run this tool.');
-        } else {
-          console.log('Note: could not determine npm global bin; skipping alias creation.');
-        }
-      } else {
-        // No collision; ensure a 'code' wrapper exists forwarding to 'coder'
-        if (globalBin) {
-          try {
-            const content = isWindows
-              ? `@echo off\r\n"%~dp0coder" %*\r\n`
-              : `#!/bin/sh\nexec "$(dirname \"$0\")/coder" "$@"\n`;
-            writeFileSync(ourShim, content);
-            if (!isWindows) chmodSync(ourShim, 0o755);
-            console.log("✓ Created 'code' wrapper -> coder");
-            installedCmds.add('code');
-          } catch (e) {
-            console.log(`⚠ Failed to create 'code' wrapper: ${e.message}`);
-          }
-        }
-      }
-
-      // Print summary for npm/pnpm/yarn
-      const list = Array.from(installedCmds).sort().join(', ');
-      console.log(`Commands installed: ${list}`);
-      if (skippedCmds.length) {
-        for (const s of skippedCmds) console.log(`Commands skipped: ${s.name} (${s.reason})`);
-      }
-      // Final friendly usage hint
-      if (installedCmds.has('code')) {
-        console.log("Use 'dev' to launch Hanzo Dev.");
-      } else {
-        console.log("Use 'dev' to launch Hanzo Dev.");
-      }
-    }
+function isExecutedDirectly() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return resolve(entry) === fileURLToPath(import.meta.url);
   } catch {
-    // non-fatal
+    return false;
   }
 }
 
-main().catch(error => {
-  console.error('Installation failed:', error);
-  process.exit(1);
-});
+if (isExecutedDirectly()) {
+  runPostinstall().catch(error => {
+    console.error('Installation failed:', error);
+    process.exit(1);
+  });
+}