vibetunnel
Version:
Terminal sharing server with web interface - supports macOS, Linux, and headless environments
237 lines • 30.6 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.patchClaudeBinary = patchClaudeBinary;
exports.checkAndPatchClaude = checkAndPatchClaude;
const child_process_1 = require("child_process");
const fs_1 = __importDefault(require("fs"));
const os_1 = __importDefault(require("os"));
const path_1 = __importDefault(require("path"));
const logger_js_1 = require("./logger.js");
const logger = (0, logger_js_1.createLogger)('claude-patcher');
// Track patched binaries for cleanup
const patchedBinaries = new Map(); // originalPath -> backupPath
/**
* Restore all patched binaries from their backups
*/
function restoreAllBinaries() {
for (const [originalPath, backupPath] of patchedBinaries.entries()) {
try {
if (fs_1.default.existsSync(backupPath)) {
fs_1.default.copyFileSync(backupPath, originalPath);
logger.debug(`Restored binary: ${originalPath}`);
// Clean up temp backup file
try {
fs_1.default.unlinkSync(backupPath);
logger.debug(`Cleaned up backup: ${backupPath}`);
}
catch (cleanupError) {
// Non-critical error, just log it
logger.debug(`Failed to clean up backup ${backupPath}:`, cleanupError);
}
}
}
catch (error) {
logger.error(`Failed to restore binary ${originalPath}:`, error);
}
}
patchedBinaries.clear();
}
// Set up cleanup handlers
let cleanupRegistered = false;
function registerCleanupHandlers() {
if (cleanupRegistered)
return;
cleanupRegistered = true;
const cleanup = () => {
restoreAllBinaries();
};
process.on('exit', cleanup);
process.on('SIGINT', () => {
cleanup();
process.exit(130); // Standard exit code for SIGINT
});
process.on('SIGTERM', () => {
cleanup();
process.exit(143); // Standard exit code for SIGTERM
});
}
function patchClaudeBinary(claudePath) {
// Check if already patched
if (patchedBinaries.has(claudePath)) {
logger.debug(`Binary already patched: ${claudePath}`);
return claudePath;
}
// Create a unique temp file for backup
const claudeFilename = path_1.default.basename(claudePath);
const tempDir = os_1.default.tmpdir();
const backupPath = path_1.default.join(tempDir, `vibetunnel-claude-backup-${Date.now()}-${claudeFilename}`);
// Create backup
fs_1.default.copyFileSync(claudePath, backupPath);
logger.debug(`Created backup at ${backupPath}`);
// Read the Claude binary
const content = fs_1.default.readFileSync(claudePath, 'utf8');
// Multiple patterns to match different variations of anti-debugging checks
const patterns = [
// Standard pattern: if(PF5())process.exit(1);
/if\([A-Za-z0-9_$]+\(\)\)process\.exit\(1\);/g,
// With spaces: if (PF5()) process.exit(1);
/if\s*\([A-Za-z0-9_$]+\(\)\)\s*process\.exit\(1\);/g,
// Different exit codes: if(PF5())process.exit(2);
/if\([A-Za-z0-9_$]+\(\)\)process\.exit\(\d+\);/g,
];
let patchedContent = content;
let patched = false;
for (const pattern of patterns) {
const newContent = patchedContent.replace(pattern, 'if(false)process.exit(1);');
if (newContent !== patchedContent) {
patchedContent = newContent;
patched = true;
logger.debug(`Applied patch for pattern: ${pattern}`);
}
}
if (!patched) {
logger.warn('No anti-debugging pattern found - Claude binary may have changed');
return claudePath;
}
// Write patched version directly over the original
fs_1.default.writeFileSync(claudePath, patchedContent);
// Track this patched binary for cleanup
patchedBinaries.set(claudePath, backupPath);
registerCleanupHandlers();
logger.log(`Patched Claude binary`);
return claudePath;
}
/**
* Checks if a command is the Claude CLI binary and patches it if necessary.
*
* @param command - The command array from fwd.ts (e.g., ["claude", "--resume"])
* @returns The potentially patched command array
*/
function checkAndPatchClaude(command) {
if (command.length === 0) {
return command;
}
// Get the base command (first element)
let baseCommand = command[0];
logger.debug(`Checking command: ${baseCommand}`);
// Step 1: Check if it's an alias and resolve it
try {
// Get the user's shell from SHELL env var, default to bash
const userShell = process.env.SHELL || '/bin/bash';
const shellName = path_1.default.basename(userShell);
// First try to check if it's an alias using the user's shell
const aliasCommand = shellName === 'zsh'
? `${userShell} -i -c "alias ${baseCommand} 2>/dev/null"`
: `${userShell} -i -c "alias ${baseCommand} 2>&1"`;
const aliasOutput = (0, child_process_1.execSync)(aliasCommand, {
encoding: 'utf8',
}).trim();
if (aliasOutput && !aliasOutput.includes('not found')) {
// Parse alias output (format may vary by shell)
// zsh: alias name='command' or name=command
// bash: alias name='command'
const match = aliasOutput.match(/^(?:alias\s+)?[^=]+=["']?(.+?)["']?$/);
if (match) {
const aliasCommand = match[1].split(' ')[0];
logger.debug(`Resolved alias: ${baseCommand} → ${aliasCommand}`);
baseCommand = aliasCommand;
}
}
}
catch {
// This is expected when alias doesn't exist
logger.debug(`No alias found for: ${baseCommand}`);
}
// Step 2: Resolve the full path if it's not already absolute
let resolvedPath = baseCommand;
if (!path_1.default.isAbsolute(baseCommand)) {
try {
// Try to find the executable in PATH using which
const whichOutput = (0, child_process_1.execSync)(`which "${baseCommand}" 2>/dev/null`, {
encoding: 'utf8',
}).trim();
if (whichOutput) {
resolvedPath = whichOutput;
logger.debug(`Found in PATH: ${resolvedPath}`);
}
else {
// Try command -v as a fallback
try {
const commandOutput = (0, child_process_1.execSync)(`command -v "${baseCommand}" 2>/dev/null`, {
encoding: 'utf8',
shell: '/bin/sh',
}).trim();
if (commandOutput && commandOutput !== baseCommand) {
resolvedPath = commandOutput;
logger.debug(`Found via command -v: ${resolvedPath}`);
}
}
catch {
// command -v also failed
}
}
}
catch {
// which failed, continue with current path
logger.debug(`Could not find ${baseCommand} in PATH`);
}
}
// Step 3: Check if it's a symlink and resolve it
try {
if (fs_1.default.existsSync(resolvedPath) && fs_1.default.lstatSync(resolvedPath).isSymbolicLink()) {
const realPath = fs_1.default.realpathSync(resolvedPath);
logger.debug(`Resolved symlink: ${resolvedPath} → ${realPath}`);
resolvedPath = realPath;
}
}
catch (error) {
logger.debug(`Could not resolve symlink: ${error}`);
}
// Step 4: Check if this is the Claude CLI binary
// We'll check for various indicators that this is Claude
if (!fs_1.default.existsSync(resolvedPath)) {
logger.debug(`Resolved path does not exist: ${resolvedPath}`);
return command;
}
// Check if this is the Claude CLI by examining file content
try {
// Read the first 1KB of the file to check the header
const fd = fs_1.default.openSync(resolvedPath, 'r');
const buffer = Buffer.alloc(1024);
const bytesRead = fs_1.default.readSync(fd, buffer, 0, 1024, 0);
fs_1.default.closeSync(fd);
const fileHeader = buffer.toString('utf8', 0, bytesRead);
// Check for Claude CLI indicators:
// 1. Shebang with node
// 2. Anthropic copyright
const isClaudeBinary = fileHeader.includes('#!/usr/bin/env') &&
fileHeader.includes('node') &&
fileHeader.includes('Anthropic PBC');
if (!isClaudeBinary) {
logger.debug(`Not a Claude CLI binary: ${path_1.default.basename(resolvedPath)}`);
return command;
}
// Now read the full file to check for anti-debugging patterns
const fullContent = fs_1.default.readFileSync(resolvedPath, 'utf8');
const hasAntiDebugging = fullContent.includes('process.exit(1)') || fullContent.includes('PF5()');
if (!hasAntiDebugging) {
logger.debug(`Claude CLI detected but no anti-debugging patterns found`);
return command;
}
}
catch (error) {
logger.debug(`Could not read file to verify Claude binary: ${error}`);
return command;
}
// Step 5: It's Claude! Patch it
logger.log(`Detected Claude CLI binary at: ${resolvedPath}`);
const patchedPath = patchClaudeBinary(resolvedPath);
// Return the command with the patched path
const patchedCommand = [patchedPath, ...command.slice(1)];
logger.log(`Using patched command: ${patchedCommand.join(' ')}`);
return patchedCommand;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"claude-patcher.js","sourceRoot":"","sources":["../../../src/server/utils/claude-patcher.ts"],"names":[],"mappings":";;;;;AA0DA,8CAuDC;AAQD,kDA0IC;AAnQD,iDAAyC;AACzC,4CAAoB;AACpB,4CAAoB;AACpB,gDAAwB;AACxB,2CAA2C;AAE3C,MAAM,MAAM,GAAG,IAAA,wBAAY,EAAC,gBAAgB,CAAC,CAAC;AAE9C,qCAAqC;AACrC,MAAM,eAAe,GAAG,IAAI,GAAG,EAAkB,CAAC,CAAC,6BAA6B;AAEhF;;GAEG;AACH,SAAS,kBAAkB;IACzB,KAAK,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,IAAI,eAAe,CAAC,OAAO,EAAE,EAAE,CAAC;QACnE,IAAI,CAAC;YACH,IAAI,YAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC9B,YAAE,CAAC,YAAY,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;gBAC1C,MAAM,CAAC,KAAK,CAAC,oBAAoB,YAAY,EAAE,CAAC,CAAC;gBAEjD,4BAA4B;gBAC5B,IAAI,CAAC;oBACH,YAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;oBAC1B,MAAM,CAAC,KAAK,CAAC,sBAAsB,UAAU,EAAE,CAAC,CAAC;gBACnD,CAAC;gBAAC,OAAO,YAAY,EAAE,CAAC;oBACtB,kCAAkC;oBAClC,MAAM,CAAC,KAAK,CAAC,6BAA6B,UAAU,GAAG,EAAE,YAAY,CAAC,CAAC;gBACzE,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,4BAA4B,YAAY,GAAG,EAAE,KAAK,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IACD,eAAe,CAAC,KAAK,EAAE,CAAC;AAC1B,CAAC;AAED,0BAA0B;AAC1B,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAC9B,SAAS,uBAAuB;IAC9B,IAAI,iBAAiB;QAAE,OAAO;IAC9B,iBAAiB,GAAG,IAAI,CAAC;IAEzB,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,kBAAkB,EAAE,CAAC;IACvB,CAAC,CAAC;IAEF,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;QACxB,OAAO,EAAE,CAAC;QACV,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,gCAAgC;IACrD,CAAC,CAAC,CAAC;IACH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;QACzB,OAAO,EAAE,CAAC;QACV,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,iCAAiC;IACtD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,iBAAiB,CAAC,UAAkB;IAClD,2BAA2B;IAC3B,IAAI,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;QACpC,MAAM,CAAC,KAAK,CAAC,2BAA2B,UAAU,EAAE,CAAC,CAAC;QACtD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,uCAAuC;IACvC,MAAM,cAAc,GAAG,cAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,YAAE,CAAC,MAAM,EAAE,CAAC;IAC5B,MAAM,UAAU,GAAG,cAAI,CAAC,IAAI,CAAC,OAAO,EAAE,4BAA4B,IAAI,CAAC,GAAG,EAAE,IAAI,cAAc,EAAE,CAAC,CAAC;IAElG,gBAAgB;IAChB,YAAE,CAAC,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACxC,MAAM,CAAC,KAAK,CAAC,qBAAqB,UAAU,EAAE,CAAC,CAAC;IAEhD,yBAAyB;IACzB,MAAM,OAAO,GAAG,YAAE,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAEpD,2EAA2E;IAC3E,MAAM,QAAQ,GAAG;QACf,8CAA8C;QAC9C,8CAA8C;QAC9C,2CAA2C;QAC3C,oDAAoD;QACpD,kDAAkD;QAClD,gDAAgD;KACjD,CAAC;IAEF,IAAI,cAAc,GAAG,OAAO,CAAC;IAC7B,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,OAAO,EAAE,2BAA2B,CAAC,CAAC;QAChF,IAAI,UAAU,KAAK,cAAc,EAAE,CAAC;YAClC,cAAc,GAAG,UAAU,CAAC;YAC5B,OAAO,GAAG,IAAI,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,8BAA8B,OAAO,EAAE,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAC;QAChF,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,mDAAmD;IACnD,YAAE,CAAC,aAAa,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;IAE7C,wCAAwC;IACxC,eAAe,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAC5C,uBAAuB,EAAE,CAAC;IAE1B,MAAM,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;IACpC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAAiB;IACnD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,uCAAuC;IACvC,IAAI,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7B,MAAM,CAAC,KAAK,CAAC,qBAAqB,WAAW,EAAE,CAAC,CAAC;IAEjD,gDAAgD;IAChD,IAAI,CAAC;QACH,2DAA2D;QAC3D,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,WAAW,CAAC;QACnD,MAAM,SAAS,GAAG,cAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAE3C,6DAA6D;QAC7D,MAAM,YAAY,GAChB,SAAS,KAAK,KAAK;YACjB,CAAC,CAAC,GAAG,SAAS,iBAAiB,WAAW,eAAe;YACzD,CAAC,CAAC,GAAG,SAAS,iBAAiB,WAAW,QAAQ,CAAC;QAEvD,MAAM,WAAW,GAAG,IAAA,wBAAQ,EAAC,YAAY,EAAE;YACzC,QAAQ,EAAE,MAAM;SACjB,CAAC,CAAC,IAAI,EAAE,CAAC;QAEV,IAAI,WAAW,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACtD,gDAAgD;YAChD,4CAA4C;YAC5C,6BAA6B;YAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACxE,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5C,MAAM,CAAC,KAAK,CAAC,mBAAmB,WAAW,MAAM,YAAY,EAAE,CAAC,CAAC;gBACjE,WAAW,GAAG,YAAY,CAAC;YAC7B,CAAC;QACH,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,4CAA4C;QAC5C,MAAM,CAAC,KAAK,CAAC,uBAAuB,WAAW,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,6DAA6D;IAC7D,IAAI,YAAY,GAAG,WAAW,CAAC;IAC/B,IAAI,CAAC,cAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;QAClC,IAAI,CAAC;YACH,iDAAiD;YACjD,MAAM,WAAW,GAAG,IAAA,wBAAQ,EAAC,UAAU,WAAW,eAAe,EAAE;gBACjE,QAAQ,EAAE,MAAM;aACjB,CAAC,CAAC,IAAI,EAAE,CAAC;YAEV,IAAI,WAAW,EAAE,CAAC;gBAChB,YAAY,GAAG,WAAW,CAAC;gBAC3B,MAAM,CAAC,KAAK,CAAC,kBAAkB,YAAY,EAAE,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,+BAA+B;gBAC/B,IAAI,CAAC;oBACH,MAAM,aAAa,GAAG,IAAA,wBAAQ,EAAC,eAAe,WAAW,eAAe,EAAE;wBACxE,QAAQ,EAAE,MAAM;wBAChB,KAAK,EAAE,SAAS;qBACjB,CAAC,CAAC,IAAI,EAAE,CAAC;oBAEV,IAAI,aAAa,IAAI,aAAa,KAAK,WAAW,EAAE,CAAC;wBACnD,YAAY,GAAG,aAAa,CAAC;wBAC7B,MAAM,CAAC,KAAK,CAAC,yBAAyB,YAAY,EAAE,CAAC,CAAC;oBACxD,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,yBAAyB;gBAC3B,CAAC;YACH,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,KAAK,CAAC,kBAAkB,WAAW,UAAU,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,iDAAiD;IACjD,IAAI,CAAC;QACH,IAAI,YAAE,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,YAAE,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC;YAC/E,MAAM,QAAQ,GAAG,YAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAC/C,MAAM,CAAC,KAAK,CAAC,qBAAqB,YAAY,MAAM,QAAQ,EAAE,CAAC,CAAC;YAChE,YAAY,GAAG,QAAQ,CAAC;QAC1B,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,iDAAiD;IACjD,yDAAyD;IACzD,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QACjC,MAAM,CAAC,KAAK,CAAC,iCAAiC,YAAY,EAAE,CAAC,CAAC;QAC9D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,4DAA4D;IAC5D,IAAI,CAAC;QACH,qDAAqD;QACrD,MAAM,EAAE,GAAG,YAAE,CAAC,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAClC,MAAM,SAAS,GAAG,YAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACtD,YAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAEjB,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;QAEzD,mCAAmC;QACnC,uBAAuB;QACvB,yBAAyB;QACzB,MAAM,cAAc,GAClB,UAAU,CAAC,QAAQ,CAAC,gBAAgB,CAAC;YACrC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC;YAC3B,UAAU,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAEvC,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,CAAC,KAAK,CAAC,4BAA4B,cAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;YACxE,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,8DAA8D;QAC9D,MAAM,WAAW,GAAG,YAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC1D,MAAM,gBAAgB,GACpB,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE3E,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,CAAC,KAAK,CAAC,0DAA0D,CAAC,CAAC;YACzE,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,CAAC,gDAAgD,KAAK,EAAE,CAAC,CAAC;QACtE,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,gCAAgC;IAChC,MAAM,CAAC,GAAG,CAAC,kCAAkC,YAAY,EAAE,CAAC,CAAC;IAC7D,MAAM,WAAW,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAEpD,2CAA2C;IAC3C,MAAM,cAAc,GAAG,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,MAAM,CAAC,GAAG,CAAC,0BAA0B,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjE,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["import { execSync } from 'child_process';\nimport fs from 'fs';\nimport os from 'os';\nimport path from 'path';\nimport { createLogger } from './logger.js';\n\nconst logger = createLogger('claude-patcher');\n\n// Track patched binaries for cleanup\nconst patchedBinaries = new Map<string, string>(); // originalPath -> backupPath\n\n/**\n * Restore all patched binaries from their backups\n */\nfunction restoreAllBinaries() {\n  for (const [originalPath, backupPath] of patchedBinaries.entries()) {\n    try {\n      if (fs.existsSync(backupPath)) {\n        fs.copyFileSync(backupPath, originalPath);\n        logger.debug(`Restored binary: ${originalPath}`);\n\n        // Clean up temp backup file\n        try {\n          fs.unlinkSync(backupPath);\n          logger.debug(`Cleaned up backup: ${backupPath}`);\n        } catch (cleanupError) {\n          // Non-critical error, just log it\n          logger.debug(`Failed to clean up backup ${backupPath}:`, cleanupError);\n        }\n      }\n    } catch (error) {\n      logger.error(`Failed to restore binary ${originalPath}:`, error);\n    }\n  }\n  patchedBinaries.clear();\n}\n\n// Set up cleanup handlers\nlet cleanupRegistered = false;\nfunction registerCleanupHandlers() {\n  if (cleanupRegistered) return;\n  cleanupRegistered = true;\n\n  const cleanup = () => {\n    restoreAllBinaries();\n  };\n\n  process.on('exit', cleanup);\n  process.on('SIGINT', () => {\n    cleanup();\n    process.exit(130); // Standard exit code for SIGINT\n  });\n  process.on('SIGTERM', () => {\n    cleanup();\n    process.exit(143); // Standard exit code for SIGTERM\n  });\n}\n\nexport function patchClaudeBinary(claudePath: string): string {\n  // Check if already patched\n  if (patchedBinaries.has(claudePath)) {\n    logger.debug(`Binary already patched: ${claudePath}`);\n    return claudePath;\n  }\n\n  // Create a unique temp file for backup\n  const claudeFilename = path.basename(claudePath);\n  const tempDir = os.tmpdir();\n  const backupPath = path.join(tempDir, `vibetunnel-claude-backup-${Date.now()}-${claudeFilename}`);\n\n  // Create backup\n  fs.copyFileSync(claudePath, backupPath);\n  logger.debug(`Created backup at ${backupPath}`);\n\n  // Read the Claude binary\n  const content = fs.readFileSync(claudePath, 'utf8');\n\n  // Multiple patterns to match different variations of anti-debugging checks\n  const patterns = [\n    // Standard pattern: if(PF5())process.exit(1);\n    /if\\([A-Za-z0-9_$]+\\(\\)\\)process\\.exit\\(1\\);/g,\n    // With spaces: if (PF5()) process.exit(1);\n    /if\\s*\\([A-Za-z0-9_$]+\\(\\)\\)\\s*process\\.exit\\(1\\);/g,\n    // Different exit codes: if(PF5())process.exit(2);\n    /if\\([A-Za-z0-9_$]+\\(\\)\\)process\\.exit\\(\\d+\\);/g,\n  ];\n\n  let patchedContent = content;\n  let patched = false;\n\n  for (const pattern of patterns) {\n    const newContent = patchedContent.replace(pattern, 'if(false)process.exit(1);');\n    if (newContent !== patchedContent) {\n      patchedContent = newContent;\n      patched = true;\n      logger.debug(`Applied patch for pattern: ${pattern}`);\n    }\n  }\n\n  if (!patched) {\n    logger.warn('No anti-debugging pattern found - Claude binary may have changed');\n    return claudePath;\n  }\n\n  // Write patched version directly over the original\n  fs.writeFileSync(claudePath, patchedContent);\n\n  // Track this patched binary for cleanup\n  patchedBinaries.set(claudePath, backupPath);\n  registerCleanupHandlers();\n\n  logger.log(`Patched Claude binary`);\n  return claudePath;\n}\n\n/**\n * Checks if a command is the Claude CLI binary and patches it if necessary.\n *\n * @param command - The command array from fwd.ts (e.g., [\"claude\", \"--resume\"])\n * @returns The potentially patched command array\n */\nexport function checkAndPatchClaude(command: string[]): string[] {\n  if (command.length === 0) {\n    return command;\n  }\n\n  // Get the base command (first element)\n  let baseCommand = command[0];\n  logger.debug(`Checking command: ${baseCommand}`);\n\n  // Step 1: Check if it's an alias and resolve it\n  try {\n    // Get the user's shell from SHELL env var, default to bash\n    const userShell = process.env.SHELL || '/bin/bash';\n    const shellName = path.basename(userShell);\n\n    // First try to check if it's an alias using the user's shell\n    const aliasCommand =\n      shellName === 'zsh'\n        ? `${userShell} -i -c \"alias ${baseCommand} 2>/dev/null\"`\n        : `${userShell} -i -c \"alias ${baseCommand} 2>&1\"`;\n\n    const aliasOutput = execSync(aliasCommand, {\n      encoding: 'utf8',\n    }).trim();\n\n    if (aliasOutput && !aliasOutput.includes('not found')) {\n      // Parse alias output (format may vary by shell)\n      // zsh: alias name='command' or name=command\n      // bash: alias name='command'\n      const match = aliasOutput.match(/^(?:alias\\s+)?[^=]+=[\"']?(.+?)[\"']?$/);\n      if (match) {\n        const aliasCommand = match[1].split(' ')[0];\n        logger.debug(`Resolved alias: ${baseCommand} → ${aliasCommand}`);\n        baseCommand = aliasCommand;\n      }\n    }\n  } catch {\n    // This is expected when alias doesn't exist\n    logger.debug(`No alias found for: ${baseCommand}`);\n  }\n\n  // Step 2: Resolve the full path if it's not already absolute\n  let resolvedPath = baseCommand;\n  if (!path.isAbsolute(baseCommand)) {\n    try {\n      // Try to find the executable in PATH using which\n      const whichOutput = execSync(`which \"${baseCommand}\" 2>/dev/null`, {\n        encoding: 'utf8',\n      }).trim();\n\n      if (whichOutput) {\n        resolvedPath = whichOutput;\n        logger.debug(`Found in PATH: ${resolvedPath}`);\n      } else {\n        // Try command -v as a fallback\n        try {\n          const commandOutput = execSync(`command -v \"${baseCommand}\" 2>/dev/null`, {\n            encoding: 'utf8',\n            shell: '/bin/sh',\n          }).trim();\n\n          if (commandOutput && commandOutput !== baseCommand) {\n            resolvedPath = commandOutput;\n            logger.debug(`Found via command -v: ${resolvedPath}`);\n          }\n        } catch {\n          // command -v also failed\n        }\n      }\n    } catch {\n      // which failed, continue with current path\n      logger.debug(`Could not find ${baseCommand} in PATH`);\n    }\n  }\n\n  // Step 3: Check if it's a symlink and resolve it\n  try {\n    if (fs.existsSync(resolvedPath) && fs.lstatSync(resolvedPath).isSymbolicLink()) {\n      const realPath = fs.realpathSync(resolvedPath);\n      logger.debug(`Resolved symlink: ${resolvedPath} → ${realPath}`);\n      resolvedPath = realPath;\n    }\n  } catch (error) {\n    logger.debug(`Could not resolve symlink: ${error}`);\n  }\n\n  // Step 4: Check if this is the Claude CLI binary\n  // We'll check for various indicators that this is Claude\n  if (!fs.existsSync(resolvedPath)) {\n    logger.debug(`Resolved path does not exist: ${resolvedPath}`);\n    return command;\n  }\n\n  // Check if this is the Claude CLI by examining file content\n  try {\n    // Read the first 1KB of the file to check the header\n    const fd = fs.openSync(resolvedPath, 'r');\n    const buffer = Buffer.alloc(1024);\n    const bytesRead = fs.readSync(fd, buffer, 0, 1024, 0);\n    fs.closeSync(fd);\n\n    const fileHeader = buffer.toString('utf8', 0, bytesRead);\n\n    // Check for Claude CLI indicators:\n    // 1. Shebang with node\n    // 2. Anthropic copyright\n    const isClaudeBinary =\n      fileHeader.includes('#!/usr/bin/env') &&\n      fileHeader.includes('node') &&\n      fileHeader.includes('Anthropic PBC');\n\n    if (!isClaudeBinary) {\n      logger.debug(`Not a Claude CLI binary: ${path.basename(resolvedPath)}`);\n      return command;\n    }\n\n    // Now read the full file to check for anti-debugging patterns\n    const fullContent = fs.readFileSync(resolvedPath, 'utf8');\n    const hasAntiDebugging =\n      fullContent.includes('process.exit(1)') || fullContent.includes('PF5()');\n\n    if (!hasAntiDebugging) {\n      logger.debug(`Claude CLI detected but no anti-debugging patterns found`);\n      return command;\n    }\n  } catch (error) {\n    logger.debug(`Could not read file to verify Claude binary: ${error}`);\n    return command;\n  }\n\n  // Step 5: It's Claude! Patch it\n  logger.log(`Detected Claude CLI binary at: ${resolvedPath}`);\n  const patchedPath = patchClaudeBinary(resolvedPath);\n\n  // Return the command with the patched path\n  const patchedCommand = [patchedPath, ...command.slice(1)];\n  logger.log(`Using patched command: ${patchedCommand.join(' ')}`);\n  return patchedCommand;\n}\n"]}