thaddeus 1.0.26 → 1.0.28

package/src/utils/nativeInstaller/packageManagers.js

@@ -0,0 +1,258 @@
+/**
+ * Package manager detection for Claude CLI
+ */
+import { readFile } from 'fs/promises';
+import memoize from 'lodash-es/memoize.js';
+import { logForDebugging } from '../debug.js';
+import { execFileNoThrow } from '../execFileNoThrow.js';
+import { getPlatform } from '../platform.js';
+/**
+ * Parses /etc/os-release to extract the distro ID and ID_LIKE fields.
+ * ID_LIKE identifies the distro family (e.g. Ubuntu has ID_LIKE=debian),
+ * letting us skip package manager execs on distros that can't have them.
+ * Returns null if the file is unreadable (pre-systemd or non-standard systems);
+ * callers fall through to the exec in that case as a conservative fallback.
+ */
+export const getOsRelease = memoize(async () => {
+    try {
+        const content = await readFile('/etc/os-release', 'utf8');
+        const idMatch = content.match(/^ID=["']?(\S+?)["']?\s*$/m);
+        const idLikeMatch = content.match(/^ID_LIKE=["']?(.+?)["']?\s*$/m);
+        return {
+            id: idMatch?.[1] ?? '',
+            idLike: idLikeMatch?.[1]?.split(' ') ?? [],
+        };
+    }
+    catch {
+        return null;
+    }
+});
+function isDistroFamily(osRelease, families) {
+    return (families.includes(osRelease.id) ||
+        osRelease.idLike.some(like => families.includes(like)));
+}
+/**
+ * Detects if the currently running Claude instance was installed via mise
+ * (a polyglot tool version manager) by checking if the executable path
+ * is within a mise installs directory.
+ *
+ * mise installs to: ~/.local/share/mise/installs/<tool>/<version>/
+ */
+export function detectMise() {
+    const execPath = process.execPath || process.argv[0] || '';
+    // Check if the executable is within a mise installs directory
+    if (/[/\\]mise[/\\]installs[/\\]/i.test(execPath)) {
+        logForDebugging(`Detected mise installation: ${execPath}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * Detects if the currently running Claude instance was installed via asdf
+ * (another polyglot tool version manager) by checking if the executable path
+ * is within an asdf installs directory.
+ *
+ * asdf installs to: ~/.asdf/installs/<tool>/<version>/
+ */
+export function detectAsdf() {
+    const execPath = process.execPath || process.argv[0] || '';
+    // Check if the executable is within an asdf installs directory
+    if (/[/\\]\.?asdf[/\\]installs[/\\]/i.test(execPath)) {
+        logForDebugging(`Detected asdf installation: ${execPath}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * Detects if the currently running Claude instance was installed via Homebrew
+ * by checking if the executable path is within a Homebrew Caskroom directory.
+ *
+ * Note: We specifically check for Caskroom because npm can also be installed via
+ * Homebrew, which would place npm global packages under the same Homebrew prefix
+ * (e.g., /opt/homebrew/lib/node_modules). We need to distinguish between:
+ * - Homebrew cask: /opt/homebrew/Caskroom/thaddeus/...
+ * - npm-global (via Homebrew's npm): /opt/homebrew/lib/node_modules/@anthropic-ai/...
+ */
+export function detectHomebrew() {
+    const platform = getPlatform();
+    // Homebrew is only for macOS and Linux
+    if (platform !== 'macos' && platform !== 'linux' && platform !== 'wsl') {
+        return false;
+    }
+    // Get the path of the currently running executable
+    const execPath = process.execPath || process.argv[0] || '';
+    // Check if the executable is within a Homebrew Caskroom directory
+    // This is specific to Homebrew cask installations
+    if (execPath.includes('/Caskroom/')) {
+        logForDebugging(`Detected Homebrew cask installation: ${execPath}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * Detects if the currently running Claude instance was installed via winget
+ * by checking if the executable path is within a WinGet directory.
+ *
+ * Winget installs to:
+ * - User: %LOCALAPPDATA%\Microsoft\WinGet\Packages
+ * - System: C:\Program Files\WinGet\Packages
+ * And creates links at: %LOCALAPPDATA%\Microsoft\WinGet\Links\
+ */
+export function detectWinget() {
+    const platform = getPlatform();
+    // Winget is only for Windows
+    if (platform !== 'windows') {
+        return false;
+    }
+    const execPath = process.execPath || process.argv[0] || '';
+    // Check for WinGet paths (handles both forward and backslashes)
+    const wingetPatterns = [
+        /Microsoft[/\\]WinGet[/\\]Packages/i,
+        /Microsoft[/\\]WinGet[/\\]Links/i,
+    ];
+    for (const pattern of wingetPatterns) {
+        if (pattern.test(execPath)) {
+            logForDebugging(`Detected winget installation: ${execPath}`);
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Detects if the currently running Claude instance was installed via pacman
+ * by querying pacman's database for file ownership.
+ *
+ * We gate on the Arch distro family before invoking pacman. On other distros
+ * like Ubuntu/Debian, 'pacman' in PATH may resolve to the pacman game
+ * (/usr/games/pacman) rather than the Arch package manager.
+ */
+export const detectPacman = memoize(async () => {
+    const platform = getPlatform();
+    if (platform !== 'linux') {
+        return false;
+    }
+    const osRelease = await getOsRelease();
+    if (osRelease && !isDistroFamily(osRelease, ['arch'])) {
+        return false;
+    }
+    const execPath = process.execPath || process.argv[0] || '';
+    const result = await execFileNoThrow('pacman', ['-Qo', execPath], {
+        timeout: 5000,
+        useCwd: false,
+    });
+    if (result.code === 0 && result.stdout) {
+        logForDebugging(`Detected pacman installation: ${result.stdout.trim()}`);
+        return true;
+    }
+    return false;
+});
+/**
+ * Detects if the currently running Claude instance was installed via a .deb package
+ * by querying dpkg's database for file ownership.
+ *
+ * We use `dpkg -S <execPath>` to check if the executable is owned by a dpkg-managed package.
+ */
+export const detectDeb = memoize(async () => {
+    const platform = getPlatform();
+    if (platform !== 'linux') {
+        return false;
+    }
+    const osRelease = await getOsRelease();
+    if (osRelease && !isDistroFamily(osRelease, ['debian'])) {
+        return false;
+    }
+    const execPath = process.execPath || process.argv[0] || '';
+    const result = await execFileNoThrow('dpkg', ['-S', execPath], {
+        timeout: 5000,
+        useCwd: false,
+    });
+    if (result.code === 0 && result.stdout) {
+        logForDebugging(`Detected deb installation: ${result.stdout.trim()}`);
+        return true;
+    }
+    return false;
+});
+/**
+ * Detects if the currently running Claude instance was installed via an RPM package
+ * by querying the RPM database for file ownership.
+ *
+ * We use `rpm -qf <execPath>` to check if the executable is owned by an RPM package.
+ */
+export const detectRpm = memoize(async () => {
+    const platform = getPlatform();
+    if (platform !== 'linux') {
+        return false;
+    }
+    const osRelease = await getOsRelease();
+    if (osRelease && !isDistroFamily(osRelease, ['fedora', 'rhel', 'suse'])) {
+        return false;
+    }
+    const execPath = process.execPath || process.argv[0] || '';
+    const result = await execFileNoThrow('rpm', ['-qf', execPath], {
+        timeout: 5000,
+        useCwd: false,
+    });
+    if (result.code === 0 && result.stdout) {
+        logForDebugging(`Detected rpm installation: ${result.stdout.trim()}`);
+        return true;
+    }
+    return false;
+});
+/**
+ * Detects if the currently running Claude instance was installed via Alpine APK
+ * by querying apk's database for file ownership.
+ *
+ * We use `apk info --who-owns <execPath>` to check if the executable is owned
+ * by an apk-managed package.
+ */
+export const detectApk = memoize(async () => {
+    const platform = getPlatform();
+    if (platform !== 'linux') {
+        return false;
+    }
+    const osRelease = await getOsRelease();
+    if (osRelease && !isDistroFamily(osRelease, ['alpine'])) {
+        return false;
+    }
+    const execPath = process.execPath || process.argv[0] || '';
+    const result = await execFileNoThrow('apk', ['info', '--who-owns', execPath], {
+        timeout: 5000,
+        useCwd: false,
+    });
+    if (result.code === 0 && result.stdout) {
+        logForDebugging(`Detected apk installation: ${result.stdout.trim()}`);
+        return true;
+    }
+    return false;
+});
+/**
+ * Memoized function to detect which package manager installed Claude
+ * Returns 'unknown' if no package manager is detected
+ */
+export const getPackageManager = memoize(async () => {
+    if (detectHomebrew()) {
+        return 'homebrew';
+    }
+    if (detectWinget()) {
+        return 'winget';
+    }
+    if (detectMise()) {
+        return 'mise';
+    }
+    if (detectAsdf()) {
+        return 'asdf';
+    }
+    if (await detectPacman()) {
+        return 'pacman';
+    }
+    if (await detectApk()) {
+        return 'apk';
+    }
+    if (await detectDeb()) {
+        return 'deb';
+    }
+    if (await detectRpm()) {
+        return 'rpm';
+    }
+    return 'unknown';
+});

package/src/utils/nativeInstaller/pidLock.js

@@ -0,0 +1,347 @@
+/**
+ * PID-Based Version Locking
+ *
+ * This module provides PID-based locking for running Claude Code versions.
+ * Unlike mtime-based locking (which can hold locks for 30 days after a crash),
+ * PID-based locking can immediately detect when a process is no longer running.
+ *
+ * Lock files contain JSON with the PID and metadata, and staleness is determined
+ * by checking if the process is still alive.
+ */
+import { basename, join } from 'path';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+import { logForDebugging } from '../debug.js';
+import { isEnvDefinedFalsy, isEnvTruthy } from '../envUtils.js';
+import { isENOENT, toError } from '../errors.js';
+import { getFsImplementation } from '../fsOperations.js';
+import { getProcessCommand } from '../genericProcessUtils.js';
+import { logError } from '../log.js';
+import { jsonParse, jsonStringify, writeFileSync_DEPRECATED, } from '../slowOperations.js';
+/**
+ * Check if PID-based version locking is enabled.
+ * When disabled, falls back to mtime-based locking (30-day timeout).
+ *
+ * Controlled by GrowthBook gate with local override:
+ * - Set ENABLE_PID_BASED_VERSION_LOCKING=true to force-enable
+ * - Set ENABLE_PID_BASED_VERSION_LOCKING=false to force-disable
+ * - If unset, GrowthBook gate (thaddeus_pid_based_version_locking) controls rollout
+ */
+export function isPidBasedLockingEnabled() {
+    const envVar = process.env.ENABLE_PID_BASED_VERSION_LOCKING;
+    // If env var is explicitly set, respect it
+    if (isEnvTruthy(envVar)) {
+        return true;
+    }
+    if (isEnvDefinedFalsy(envVar)) {
+        return false;
+    }
+    // GrowthBook controls gradual rollout (returns false for external users)
+    return getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_pid_based_version_locking', false);
+}
+// Fallback stale timeout (2 hours) - used when PID check is inconclusive
+// This is much shorter than the previous 30-day timeout but still allows
+// for edge cases like network filesystems where PID check might fail
+const FALLBACK_STALE_MS = 2 * 60 * 60 * 1000;
+/**
+ * Check if a process with the given PID is currently running
+ * Uses signal 0 which doesn't actually send a signal but checks if we can
+ */
+export function isProcessRunning(pid) {
+    // PID 0 is special - it refers to the current process group, not a real process
+    // PID 1 is init/systemd and is always running but shouldn't be considered for locks
+    if (pid <= 1) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate that a running process is actually a Claude process
+ * This helps mitigate PID reuse issues
+ */
+function isClaudeProcess(pid, expectedExecPath) {
+    if (!isProcessRunning(pid)) {
+        return false;
+    }
+    // If the PID matches our current process, we know it's valid
+    // This handles test environments where the command might not contain 'claude'
+    if (pid === process.pid) {
+        return true;
+    }
+    try {
+        const command = getProcessCommand(pid);
+        if (!command) {
+            // If we can't get the command, trust the PID check
+            // This is conservative - we'd rather not delete a running version
+            return true;
+        }
+        // Check if the command contains 'claude' or the expected exec path
+        const normalizedCommand = command.toLowerCase();
+        const normalizedExecPath = expectedExecPath.toLowerCase();
+        return (normalizedCommand.includes('claude') ||
+            normalizedCommand.includes(normalizedExecPath));
+    }
+    catch {
+        // If command check fails, trust the PID check
+        return true;
+    }
+}
+/**
+ * Read and parse a lock file's content
+ */
+export function readLockContent(lockFilePath) {
+    const fs = getFsImplementation();
+    try {
+        const content = fs.readFileSync(lockFilePath, { encoding: 'utf8' });
+        if (!content || content.trim() === '') {
+            return null;
+        }
+        const parsed = jsonParse(content);
+        // Validate required fields
+        if (typeof parsed.pid !== 'number' || !parsed.version || !parsed.execPath) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a lock file represents an active lock (process still running)
+ */
+export function isLockActive(lockFilePath) {
+    const content = readLockContent(lockFilePath);
+    if (!content) {
+        return false;
+    }
+    const { pid, execPath } = content;
+    // Primary check: is the process running?
+    if (!isProcessRunning(pid)) {
+        return false;
+    }
+    // Secondary validation: is it actually a Claude process?
+    // This helps with PID reuse scenarios
+    if (!isClaudeProcess(pid, execPath)) {
+        logForDebugging(`Lock PID ${pid} is running but does not appear to be Thaddeus - treating as stale`);
+        return false;
+    }
+    // Fallback: if the lock is very old (> 2 hours) and we can't validate
+    // the command, be conservative and consider it potentially stale
+    // This handles edge cases like network filesystems
+    const fs = getFsImplementation();
+    try {
+        const stats = fs.statSync(lockFilePath);
+        const age = Date.now() - stats.mtimeMs;
+        if (age > FALLBACK_STALE_MS) {
+            // Double-check that we can still see the process
+            if (!isProcessRunning(pid)) {
+                return false;
+            }
+        }
+    }
+    catch {
+        // If we can't stat the file, trust the PID check
+    }
+    return true;
+}
+/**
+ * Write lock content to a file atomically
+ */
+function writeLockFile(lockFilePath, content) {
+    const fs = getFsImplementation();
+    const tempPath = `${lockFilePath}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        writeFileSync_DEPRECATED(tempPath, jsonStringify(content, null, 2), {
+            encoding: 'utf8',
+            flush: true,
+        });
+        fs.renameSync(tempPath, lockFilePath);
+    }
+    catch (error) {
+        // Clean up temp file on failure (best-effort)
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors (ENOENT expected if write failed before file creation)
+        }
+        throw error;
+    }
+}
+/**
+ * Try to acquire a lock on a version file
+ * Returns a release function if successful, null if the lock is already held
+ */
+export async function tryAcquireLock(versionPath, lockFilePath) {
+    const fs = getFsImplementation();
+    const versionName = basename(versionPath);
+    // Check if there's an existing active lock (including by our own process)
+    // Use isLockActive for consistency with cleanup - it checks both PID running AND
+    // validates it's actually a Claude process (to handle PID reuse scenarios)
+    if (isLockActive(lockFilePath)) {
+        const existingContent = readLockContent(lockFilePath);
+        logForDebugging(`Cannot acquire lock for ${versionName} - held by PID ${existingContent?.pid}`);
+        return null;
+    }
+    // Try to acquire the lock
+    const lockContent = {
+        pid: process.pid,
+        version: versionName,
+        execPath: process.execPath,
+        acquiredAt: Date.now(),
+    };
+    try {
+        writeLockFile(lockFilePath, lockContent);
+        // Verify we actually got the lock (race condition check)
+        const verifyContent = readLockContent(lockFilePath);
+        if (verifyContent?.pid !== process.pid) {
+            // Another process won the race
+            return null;
+        }
+        logForDebugging(`Acquired PID lock for ${versionName} (PID ${process.pid})`);
+        // Return release function
+        return () => {
+            try {
+                // Only release if we still own the lock
+                const currentContent = readLockContent(lockFilePath);
+                if (currentContent?.pid === process.pid) {
+                    fs.unlinkSync(lockFilePath);
+                    logForDebugging(`Released PID lock for ${versionName}`);
+                }
+            }
+            catch (error) {
+                logForDebugging(`Failed to release lock for ${versionName}: ${error}`);
+            }
+        };
+    }
+    catch (error) {
+        logForDebugging(`Failed to acquire lock for ${versionName}: ${error}`);
+        return null;
+    }
+}
+/**
+ * Acquire a lock and hold it for the lifetime of the process
+ * This is used for locking the currently running version
+ */
+export async function acquireProcessLifetimeLock(versionPath, lockFilePath) {
+    const release = await tryAcquireLock(versionPath, lockFilePath);
+    if (!release) {
+        return false;
+    }
+    // Register cleanup on process exit
+    const cleanup = () => {
+        try {
+            release();
+        }
+        catch {
+            // Ignore errors during process exit
+        }
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Don't call release() - we want to hold the lock until process exits
+    return true;
+}
+/**
+ * Execute a callback while holding a lock
+ * Returns true if the callback executed, false if lock couldn't be acquired
+ */
+export async function withLock(versionPath, lockFilePath, callback) {
+    const release = await tryAcquireLock(versionPath, lockFilePath);
+    if (!release) {
+        return false;
+    }
+    try {
+        await callback();
+        return true;
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Get information about all version locks for diagnostics
+ */
+export function getAllLockInfo(locksDir) {
+    const fs = getFsImplementation();
+    const lockInfos = [];
+    try {
+        const lockFiles = fs
+            .readdirStringSync(locksDir)
+            .filter((f) => f.endsWith('.lock'));
+        for (const lockFile of lockFiles) {
+            const lockFilePath = join(locksDir, lockFile);
+            const content = readLockContent(lockFilePath);
+            if (content) {
+                lockInfos.push({
+                    version: content.version,
+                    pid: content.pid,
+                    isProcessRunning: isProcessRunning(content.pid),
+                    execPath: content.execPath,
+                    acquiredAt: new Date(content.acquiredAt),
+                    lockFilePath,
+                });
+            }
+        }
+    }
+    catch (error) {
+        if (isENOENT(error)) {
+            return lockInfos;
+        }
+        logError(toError(error));
+    }
+    return lockInfos;
+}
+/**
+ * Clean up stale locks (locks where the process is no longer running)
+ * Returns the number of locks cleaned up
+ *
+ * Handles both:
+ * - PID-based locks (files containing JSON with PID)
+ * - Legacy proper-lockfile locks (directories created by mtime-based locking)
+ */
+export function cleanupStaleLocks(locksDir) {
+    const fs = getFsImplementation();
+    let cleanedCount = 0;
+    try {
+        const lockEntries = fs
+            .readdirStringSync(locksDir)
+            .filter((f) => f.endsWith('.lock'));
+        for (const lockEntry of lockEntries) {
+            const lockFilePath = join(locksDir, lockEntry);
+            try {
+                const stats = fs.lstatSync(lockFilePath);
+                if (stats.isDirectory()) {
+                    // Legacy proper-lockfile directory lock - always remove when PID-based
+                    // locking is enabled since these are from a different locking mechanism
+                    fs.rmSync(lockFilePath, { recursive: true, force: true });
+                    cleanedCount++;
+                    logForDebugging(`Cleaned up legacy directory lock: ${lockEntry}`);
+                }
+                else if (!isLockActive(lockFilePath)) {
+                    // PID-based file lock with no running process
+                    fs.unlinkSync(lockFilePath);
+                    cleanedCount++;
+                    logForDebugging(`Cleaned up stale lock: ${lockEntry}`);
+                }
+            }
+            catch {
+                // Ignore individual cleanup errors
+            }
+        }
+    }
+    catch (error) {
+        if (isENOENT(error)) {
+            return 0;
+        }
+        logError(toError(error));
+    }
+    return cleanedCount;
+}