@oxis-dev/tessra 2.19.3 → 2.19.5

package/README.md

@@ -4,12 +4,27 @@ Semantic code intelligence engine for AI agents. Tessra indexes your codebase an
 
 ## Install
 
-```bash
+```sh
 npm install -g @oxis-dev/tessra
 ```
 
 Requires a valid Tessra license. Get one at [oxis.dev/tessra](https://oxis.dev/tessra).
 
+On Windows and Linux, Tessra now checks whether the global npm bin directory is available in
+`PATH` during `postinstall`.
+
+- Windows: Tessra attempts to repair the user `PATH` automatically if `%APPDATA%\\npm` is missing.
+- Linux: Tessra attempts a safe shell-profile fix when the npm global bin directory lives under
+  the user's home directory.
+- If automatic repair is not safe or fails, the installer prints the exact command or path the
+  user needs to add manually.
+
+After a PATH repair, open a new terminal and run:
+
+```sh
+tessra --version
+```
+
 ---
 
 ## Quick start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxis-dev/tessra",
-  "version": "2.19.3",
+  "version": "2.19.5",
   "description": "MCP server for AI coding tools and agents. Provides semantic codebase context for Cursor, Claude Code, Codex, Copilot, Antigravity, and CLI workflows without requiring full file uploads.",
   "license": "UNLICENSED",
   "author": {

package/scripts/postinstall.js

@@ -19,6 +19,9 @@ const VERSION = require('../package.json').version;
 const BIN_DIR = path.join(__dirname, '..', 'bin');
 const BIN_PATH_UNIX = path.join(BIN_DIR, 'tessra');
 const BIN_PATH_WIN = path.join(BIN_DIR, 'tessra.exe');
+const PATH_DELIMITER = process.platform === 'win32' ? ';' : ':';
+const LINUX_PATH_MARKER_START = '# >>> tessra npm bin >>>';
+const LINUX_PATH_MARKER_END = '# <<< tessra npm bin <<<';
 
 // ── Detección de plataforma ──────────────────────────────────────────────────
 
@@ -126,6 +129,258 @@ function extractFromTar(buffer, targetName) {
   return null;
 }
 
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function normalizePathForCompare(targetPath) {
+  const resolved = path.resolve(targetPath);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function pathContains(targetPath, pathValue) {
+  const normalizedTarget = normalizePathForCompare(targetPath);
+  return (pathValue || '')
+    .split(PATH_DELIMITER)
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .some((entry) => normalizePathForCompare(entry) === normalizedTarget);
+}
+
+function profileReferencesBinDir(profileContent, binDir) {
+  return profileContent.includes(binDir);
+}
+
+function inferGlobalPrefix() {
+  if (process.env.npm_config_prefix) {
+    return process.env.npm_config_prefix;
+  }
+
+  const packageRoot = path.resolve(__dirname, '..');
+  const parts = packageRoot.split(path.sep);
+  const nodeModulesIndex = parts.lastIndexOf('node_modules');
+
+  if (nodeModulesIndex === -1) {
+    return null;
+  }
+
+  let prefixParts = parts.slice(0, nodeModulesIndex);
+  if (prefixParts[prefixParts.length - 1] === 'lib') {
+    prefixParts = prefixParts.slice(0, -1);
+  }
+
+  if (prefixParts.length === 0) {
+    return null;
+  }
+
+  return prefixParts.join(path.sep);
+}
+
+function getGlobalBinDir() {
+  const prefix = inferGlobalPrefix();
+  if (!prefix) {
+    return null;
+  }
+  return process.platform === 'win32' ? prefix : path.join(prefix, 'bin');
+}
+
+function printManualFix(binDir) {
+  if (process.platform === 'win32') {
+    console.warn(`tessra: agrega esta ruta a tu PATH de usuario: ${binDir}`);
+    return;
+  }
+
+  console.warn(`tessra: agrega esta linea a tu shell profile: export PATH="$PATH:${binDir}"`);
+}
+
+function repairWindowsUserPath(binDir) {
+  const currentUserPath = execFileSync(
+    'powershell.exe',
+    ['-NoProfile', '-Command', "[Environment]::GetEnvironmentVariable('Path','User')"],
+    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+  ).trim();
+
+  if (pathContains(binDir, currentUserPath)) {
+    return { changed: false };
+  }
+
+  const nextPath = [currentUserPath, binDir].filter(Boolean).join(';');
+  const escapedPath = nextPath.replace(/'/g, "''");
+
+  execFileSync(
+    'powershell.exe',
+    [
+      '-NoProfile',
+      '-Command',
+      `[Environment]::SetEnvironmentVariable('Path', '${escapedPath}', 'User')`,
+    ],
+    { stdio: ['ignore', 'pipe', 'pipe'] }
+  );
+
+  process.env.PATH = process.env.PATH ? `${process.env.PATH};${binDir}` : binDir;
+  return { changed: true };
+}
+
+function detectLinuxShellProfile() {
+  const home = process.env.HOME;
+  if (!home) {
+    return null;
+  }
+
+  const shellName = path.basename(process.env.SHELL || '');
+  if (shellName === 'bash') {
+    return path.join(home, '.bashrc');
+  }
+  if (shellName === 'zsh') {
+    return path.join(home, '.zshrc');
+  }
+  return path.join(home, '.profile');
+}
+
+function detectLinuxShellProfiles() {
+  const home = process.env.HOME;
+  if (!home) {
+    return [];
+  }
+
+  const shellName = path.basename(process.env.SHELL || '');
+  const profiles = [];
+
+  if (shellName === 'bash') {
+    profiles.push(path.join(home, '.bashrc'));
+  } else if (shellName === 'zsh') {
+    profiles.push(path.join(home, '.zshrc'));
+  }
+
+  profiles.push(path.join(home, '.profile'));
+
+  return [...new Set(profiles)];
+}
+
+function upsertLinuxProfilePath(profilePath, binDir) {
+  let profileContent = '';
+  if (fs.existsSync(profilePath)) {
+    profileContent = fs.readFileSync(profilePath, 'utf8');
+  }
+
+  const blockRegex = new RegExp(
+    `${escapeRegExp(LINUX_PATH_MARKER_START)}[\\s\\S]*?${escapeRegExp(LINUX_PATH_MARKER_END)}`,
+    'm'
+  );
+
+  if (blockRegex.test(profileContent)) {
+    if (profileReferencesBinDir(profileContent, binDir)) {
+      return { changed: false, configured: true };
+    }
+
+    const nextContent = profileContent.replace(
+      blockRegex,
+      `${LINUX_PATH_MARKER_START}\nexport PATH="$PATH:${binDir}"\n${LINUX_PATH_MARKER_END}`
+    );
+    fs.writeFileSync(profilePath, nextContent);
+    return { changed: true, configured: true };
+  }
+
+  if (profileReferencesBinDir(profileContent, binDir)) {
+    return { changed: false, configured: true };
+  }
+
+  const prefix = profileContent && !profileContent.endsWith('\n') ? '\n' : '';
+  const block =
+    `${prefix}${LINUX_PATH_MARKER_START}\n` +
+    `export PATH="$PATH:${binDir}"\n` +
+    `${LINUX_PATH_MARKER_END}\n`;
+  fs.appendFileSync(profilePath, block);
+  return { changed: true, configured: true };
+}
+
+function repairLinuxShellPath(binDir) {
+  const home = process.env.HOME;
+  if (!home) {
+    return { changed: false, reason: 'missing-home' };
+  }
+
+  const profilePaths = detectLinuxShellProfiles();
+  if (profilePaths.length === 0) {
+    return { changed: false, reason: 'missing-profile' };
+  }
+
+  const changedProfiles = [];
+  const configuredProfiles = [];
+
+  for (const profilePath of profilePaths) {
+    const result = upsertLinuxProfilePath(profilePath, binDir);
+    if (result.configured) {
+      configuredProfiles.push(profilePath);
+    }
+    if (result.changed) {
+      changedProfiles.push(profilePath);
+    }
+  }
+
+  process.env.PATH = process.env.PATH ? `${process.env.PATH}:${binDir}` : binDir;
+  return {
+    changed: changedProfiles.length > 0,
+    configured: configuredProfiles.length > 0,
+    profilePath: detectLinuxShellProfile() || profilePaths[0],
+    profilePaths: configuredProfiles,
+  };
+}
+
+function ensureGlobalBinOnPath() {
+  const binDir = getGlobalBinDir();
+  if (!binDir) {
+    console.warn('tessra: no se pudo inferir el directorio global de npm para verificar PATH.');
+    return;
+  }
+
+  if (pathContains(binDir, process.env.PATH || '')) {
+    console.log(`tessra: comando global disponible en PATH (${binDir}).`);
+    return;
+  }
+
+  if (process.platform === 'win32') {
+    try {
+      const result = repairWindowsUserPath(binDir);
+      if (result.changed) {
+        console.log('tessra: PATH reparado en Windows.');
+      } else {
+        console.log('tessra: PATH de usuario ya estaba configurado en Windows.');
+      }
+      console.log('tessra: abre una PowerShell nueva y ejecuta: tessra --version');
+      return;
+    } catch (err) {
+      console.warn('tessra: no se pudo reparar PATH automaticamente en Windows.');
+      console.warn(`tessra: ${err.message}`);
+      printManualFix(binDir);
+      return;
+    }
+  }
+
+  if (process.platform === 'linux') {
+    try {
+      const result = repairLinuxShellPath(binDir);
+      if (result.changed) {
+        console.log(`tessra: PATH reparado en Linux via ${result.profilePaths.join(', ')}.`);
+        console.log(`tessra: para usarlo en esta terminal ejecuta: source ${result.profilePath}`);
+        console.log('tessra: en una terminal nueva ya deberia reconocer: tessra --version');
+      } else if (result.configured) {
+        console.log(`tessra: PATH ya configurado en Linux via ${result.profilePaths.join(', ')}.`);
+        console.log(`tessra: si esta terminal no lo ve aun, ejecuta: source ${result.profilePath}`);
+      } else {
+        console.warn('tessra: no se aplico auto-fix de PATH en Linux.');
+        printManualFix(binDir);
+      }
+      return;
+    } catch (err) {
+      console.warn('tessra: no se pudo reparar PATH automaticamente en Linux.');
+      console.warn(`tessra: ${err.message}`);
+      printManualFix(binDir);
+      return;
+    }
+  }
+}
+
 // ── Main ─────────────────────────────────────────────────────────────────────
 
 async function main() {
@@ -167,6 +422,8 @@ async function main() {
     // --version puede fallar si el binario requiere inicialización — no es fatal
   }
 
+  ensureGlobalBinOnPath();
+
   console.log(`tessra: binario instalado correctamente en ${dest}`);
 }