codexdb-sdk 0.1.16 → 0.1.18

package/DEFAULT_DATA_DIRECTORY.md

@@ -0,0 +1,183 @@
+# CodexDB SDK - Default Data Directory
+
+## Novo Comportamento
+
+A partir desta versão, o SDK CodexDB Node.js possui um comportamento padrão para armazenamento de dados:
+
+### ✨ Comportamento Padrão (Sem opção `file`)
+
+Quando você criar um cliente sem especificar o arquivo:
+
+```javascript
+const { CodexClient } = require('codexdb-sdk');
+const client = new CodexClient();
+```
+
+O SDK automaticamente:
+- Usa o diretório `.codex-data` na pasta corrente
+- Usa `default.db` como nome do arquivo padrão
+- Cria o diretório `.codex-data` se não existir
+- Inicializa o diretório na primeira operação
+
+**Resultado**: Arquivo em `.codex-data/default.db` no diretório corrente
+
+### 🎯 Comportamento com Opção `file`
+
+Você ainda pode especificar um arquivo customizado:
+
+```javascript
+// Opção 1: Caminho completo
+const client1 = new CodexClient({ 
+  file: '/path/to/my-database.db' 
+});
+
+// Opção 2: Caminho relativo
+const client2 = new CodexClient({ 
+  file: 'my-data/custom.db' 
+});
+
+// Opção 3: Apenas o nome do arquivo
+const client3 = new CodexClient({ 
+  file: 'data.db' 
+});
+```
+
+Em todos os casos:
+- O caminho é resolvido em relação ao diretório corrente (`process.cwd()`)
+- O diretório é criado automaticamente se não existir
+- O arquivo é criado na primeira operação
+
+## Exemplos
+
+### Exemplo 1: Uso Padrão
+
+```javascript
+const { CodexClient } = require('codexdb-sdk');
+
+(async () => {
+  // Sem opções - usa .codex-data/default.db
+  const client = new CodexClient();
+
+  // O diretório é criado automaticamente na primeira operação
+  await client.set('chave', { valor: 'dados' });
+  
+  const dados = await client.get('chave');
+  console.log(dados); // { valor: 'dados' }
+})();
+```
+
+### Exemplo 2: Uso com Diretório Customizado
+
+```javascript
+const { CodexClient } = require('codexdb-sdk');
+
+(async () => {
+  // Com arquivo customizado
+  const client = new CodexClient({ 
+    file: 'dados/meu-banco.db' 
+  });
+
+  await client.set('usuario', { nome: 'João' });
+  const usuario = await client.get('usuario');
+  console.log(usuario); // { nome: 'João' }
+})();
+```
+
+### Exemplo 3: Com Criptografia e Ledger
+
+```javascript
+const { CodexClient } = require('codexdb-sdk');
+
+(async () => {
+  const client = new CodexClient({
+    // Se não especificar 'file', usa .codex-data/default.db
+    encryptionKey: 'minha-chave-secreta',
+    ledger: true
+  });
+
+  await client.set('dados-sensíveis', { token: '...' });
+})();
+```
+
+## Método `initialize()`
+
+Você pode chamar explicitamente `initialize()` para garantir que o diretório foi criado:
+
+```javascript
+const { CodexClient } = require('codexdb-sdk');
+
+const client = new CodexClient();
+
+// Cria o diretório .codex-data explicitamente
+await client.initialize();
+
+// Agora é seguro fazer operações
+await client.set('chave', { valor: 'dado' });
+```
+
+**Nota**: O método `initialize()` é chamado automaticamente na primeira operação (set, get, delete, keys, has, clear), então geralmente você não precisa chamar explicitamente.
+
+## Estrutura de Diretórios
+
+### Padrão (sem opção `file`)
+```
+projeto/
+├── .codex-data/          ← Criado automaticamente
+│   └── default.db        ← Arquivo de banco de dados
+├── node_modules/
+├── package.json
+└── app.js
+```
+
+### Custom (com opção `file`)
+```
+projeto/
+├── dados/                ← Criado automaticamente se necessário
+│   └── meu-banco.db      ← Arquivo customizado
+├── node_modules/
+├── package.json
+└── app.js
+```
+
+## Testes Unitários
+
+Para validar o comportamento padrão, execute:
+
+```bash
+npm run test:unit
+```
+
+Os testes cobrem:
+- ✓ Uso do diretório padrão `.codex-data`
+- ✓ Uso de arquivo customizado
+- ✓ Criação automática de diretórios
+- ✓ Suporte a múltiplos níveis de diretórios
+- ✓ Propriedades do cliente (encriptação, ledger)
+- ✓ Flag `_initialized`
+
+## Compatibilidade
+
+- **Versão anterior**: `options.file` era obrigatório
+- **Versão nova**: `options.file` é opcional (usa `.codex-data/default.db` por padrão)
+
+Se seu código já usa a opção `file`, ele continuará funcionando normalmente! ✓
+
+## Migração
+
+Se você tinha código assim:
+
+```javascript
+// ❌ Antigo (file era obrigatório)
+const client = new CodexClient({ 
+  file: './.codex-data/default.db' 
+});
+```
+
+Você pode simplificar para:
+
+```javascript
+// ✓ Novo (file é opcional)
+const client = new CodexClient();
+```
+
+Ambas as formas funcionam, mas a segunda é mais simples! 🎉

package/example_app_default.js

@@ -0,0 +1,66 @@
+const { CodexClient } = require('./index');
+
+// Example 1: Using default data directory (.codex-data/default.db)
+(async () => {
+  console.log('Example 1: Using default data directory\n');
+
+  // No file option needed - uses .codex-data/default.db automatically
+  const client = new CodexClient();
+
+  console.log('Database file:', client.file);
+  console.log('Data directory:', client.dataDir);
+  console.log('Initialized:', client._initialized);
+
+  // Initialize creates the directory if it doesn't exist
+  await client.initialize();
+  console.log('After initialize - Initialized:', client._initialized);
+
+  try {
+    // Set a value
+    await client.set('message', { text: 'Hello from CodexDB!' });
+    console.log('✓ Set message');
+
+    // Get the value
+    const value = await client.get('message');
+    console.log('✓ Got message:', value.text);
+
+    // List all keys
+    const keys = await client.keys();
+    console.log('✓ All keys:', keys);
+
+    // Check if key exists
+    const exists = await client.has('message');
+    console.log('✓ Key exists:', exists);
+
+    // Delete the key
+    await client.delete('message');
+    console.log('✓ Deleted message');
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+})();
+
+// Example 2: Using custom data directory
+console.log('\n---\n');
+console.log('Example 2: Using custom data directory\n');
+
+(async () => {
+  const path = require('path');
+
+  // Custom file path - resolved relative to current working directory
+  const client = new CodexClient({ file: 'custom-data.db' });
+
+  console.log('Database file:', client.file);
+  console.log('Data directory:', client.dataDir);
+
+  try {
+    // Operations automatically initialize the directory
+    await client.set('config', { theme: 'dark', language: 'pt-BR' });
+    console.log('✓ Set config');
+
+    const config = await client.get('config');
+    console.log('✓ Got config:', config);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+})();

package/index.js

@@ -1,4 +1,6 @@
 const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs/promises');
 
 function execCodexCli(cliPath, args, env = {}) {
   return new Promise((resolve, reject) => {
@@ -12,14 +14,32 @@ function execCodexCli(cliPath, args, env = {}) {
   });
 }
 
+async function ensureDataDirectory(dataPath) {
+  try {
+    await fs.mkdir(dataPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== 'EEXIST') {
+      throw error;
+    }
+  }
+}
+
 class CodexClient {
   constructor(options = {}) {
-    if (!options.file) {
-      throw new Error('options.file is required (path to database file)');
+    // If no file is provided, use default: .codex-data/default.db
+    let file = options.file;
+    if (!file) {
+      const dataDir = path.resolve(process.cwd(), '.codex-data');
+      file = path.join(dataDir, 'default.db');
+    } else {
+      // If file is provided but it's just a filename (no path separators),
+      // resolve it relative to current working directory
+      file = path.resolve(process.cwd(), file);
     }
 
     this.cliPath = options.cliPath || 'codex-cli';
-    this.file = options.file;
+    this.file = file;
+    this.dataDir = path.dirname(this.file);
     this.ledger = options.ledger ? '--ledger' : null;
     this.env = {};
 
@@ -28,6 +48,18 @@ class CodexClient {
     }
   }
 
+  async initialize() {
+    // Create data directory if it doesn't exist
+    await ensureDataDirectory(this.dataDir);
+    this._initialized = true;
+  }
+
+  async _ensureInitialized() {
+    if (!this._initialized) {
+      await this.initialize();
+    }
+  }
+
   _baseArgs() {
     const args = ['--file', this.file];
     if (this.ledger) args.push(this.ledger);
@@ -35,6 +67,7 @@ class CodexClient {
   }
 
   async set(key, value) {
+    await this._ensureInitialized();
     const payload = JSON.stringify(value);
     const args = [...this._baseArgs(), 'set', key, payload];
     await execCodexCli(this.cliPath, args, this.env);
@@ -42,6 +75,7 @@ class CodexClient {
   }
 
   async get(key) {
+    await this._ensureInitialized();
     const args = [...this._baseArgs(), 'get', key];
     const raw = await execCodexCli(this.cliPath, args, this.env);
     if (!raw) return null;
@@ -49,12 +83,14 @@ class CodexClient {
   }
 
   async delete(key) {
+    await this._ensureInitialized();
     const args = [...this._baseArgs(), 'delete', key];
     await execCodexCli(this.cliPath, args, this.env);
     return true;
   }
 
   async keys() {
+    await this._ensureInitialized();
     const args = [...this._baseArgs(), 'keys'];
     const raw = await execCodexCli(this.cliPath, args, this.env);
     if (!raw) return [];
@@ -62,12 +98,14 @@ class CodexClient {
   }
 
   async has(key) {
+    await this._ensureInitialized();
     const args = [...this._baseArgs(), 'has', key];
     const raw = await execCodexCli(this.cliPath, args, this.env);
     return raw.trim() === 'true';
   }
 
   async clear() {
+    await this._ensureInitialized();
     const args = [...this._baseArgs(), 'clear'];
     await execCodexCli(this.cliPath, args, this.env);
     return true;

package/index.test.js

@@ -0,0 +1,339 @@
+const path = require('path');
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const { CodexClient } = require('./index');
+
+// Test utilities
+const TEST_DIR = path.join(__dirname, '.test-temp');
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function setupTestDir() {
+  try {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  } catch (e) {
+    // ignore
+  }
+  await fs.mkdir(TEST_DIR, { recursive: true });
+}
+
+async function cleanupTestDir() {
+  try {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  } catch (e) {
+    // ignore
+  }
+}
+
+async function dirExists(dirPath) {
+  try {
+    const stats = await fs.stat(dirPath);
+    return stats.isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
+// Color console output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function logTest(name) {
+  log(`\n  ✓ ${name}`, 'blue');
+}
+
+function logPass(message) {
+  log(`    ✓ ${message}`, 'green');
+}
+
+function logFail(message) {
+  log(`    ✗ ${message}`, 'red');
+  process.exitCode = 1;
+}
+
+// ============================================
+// TESTS
+// ============================================
+
+async function testDefaultDataDirectory() {
+  logTest('Default data directory behavior');
+
+  await cleanupTestDir();
+  await setupTestDir();
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    // Create client without file option
+    const client = new CodexClient();
+
+    // Check that file path includes .codex-data
+    const expectedPath = path.join(TEST_DIR, '.codex-data', 'default.db');
+    if (client.file === expectedPath) {
+      logPass(`File path defaults to ${expectedPath}`);
+    } else {
+      logFail(
+        `File path should be ${expectedPath}, got ${client.file}`
+      );
+    }
+
+    // Check dataDir
+    const expectedDataDir = path.join(TEST_DIR, '.codex-data');
+    if (client.dataDir === expectedDataDir) {
+      logPass(`Data directory defaults to ${expectedDataDir}`);
+    } else {
+      logFail(
+        `Data directory should be ${expectedDataDir}, got ${client.dataDir}`
+      );
+    }
+
+    // Check that directory is created on initialize
+    const existsBefore = await dirExists(expectedDataDir);
+    if (!existsBefore) {
+      logPass('Directory does not exist before initialize()');
+    } else {
+      logFail('Directory should not exist before initialize()');
+    }
+
+    await client.initialize();
+
+    const existsAfter = await dirExists(expectedDataDir);
+    if (existsAfter) {
+      logPass('Directory created after initialize()');
+    } else {
+      logFail('Directory should be created after initialize()');
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+async function testCustomFileOption() {
+  logTest('Custom file option handling');
+
+  await cleanupTestDir();
+  await setupTestDir();
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    // Test with full path
+    const customPath = path.join(TEST_DIR, 'custom', 'my-db.db');
+    const client = new CodexClient({ file: customPath });
+
+    if (client.file === customPath) {
+      logPass(`Full path option preserved: ${customPath}`);
+    } else {
+      logFail(
+        `File path should be ${customPath}, got ${client.file}`
+      );
+    }
+
+    // Test with relative filename
+    const client2 = new CodexClient({ file: 'my-db.db' });
+    const expectedPath = path.resolve(process.cwd(), 'my-db.db');
+
+    if (client2.file === expectedPath) {
+      logPass(`Relative filename resolved to: ${expectedPath}`);
+    } else {
+      logFail(
+        `File path should be ${expectedPath}, got ${client2.file}`
+      );
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+async function testDirectoryCreationOnDemand() {
+  logTest('Directory creation on first operation');
+
+  await cleanupTestDir();
+  await setupTestDir();
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    const client = new CodexClient();
+    const dataDir = client.dataDir;
+
+    // Check directory doesn't exist yet
+    const existsBefore = await dirExists(dataDir);
+    if (!existsBefore) {
+      logPass('Directory does not exist before first operation');
+    } else {
+      logFail('Directory should not exist before first operation');
+    }
+
+    // Call initialize (which would be called automatically in real operations)
+    await client.initialize();
+
+    // Check directory now exists
+    const existsAfter = await dirExists(dataDir);
+    if (existsAfter) {
+      logPass('Directory created on initialize()');
+    } else {
+      logFail('Directory should be created on initialize()');
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+async function testMultipleLevelsPath() {
+  logTest('Multiple levels of directory creation');
+
+  await cleanupTestDir();
+  await setupTestDir();
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    const customPath = path.join(TEST_DIR, 'a', 'b', 'c', 'db.db');
+    const client = new CodexClient({ file: customPath });
+
+    const dataDir = client.dataDir;
+    const existsBefore = await dirExists(dataDir);
+
+    if (!existsBefore) {
+      logPass('Nested directories do not exist before initialize()');
+    } else {
+      logFail('Nested directories should not exist before initialize()');
+    }
+
+    await client.initialize();
+
+    const existsAfter = await dirExists(dataDir);
+    if (existsAfter) {
+      logPass('Nested directories created: ' + dataDir);
+    } else {
+      logFail('Nested directories should be created');
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+async function testClientProperties() {
+  logTest('Client properties and configuration');
+
+  await cleanupTestDir();
+  await setupTestDir();
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    const client = new CodexClient({
+      encryptionKey: 'secret-key',
+      ledger: true,
+    });
+
+    if (client.env.CODEX_KEY === 'secret-key') {
+      logPass('Encryption key stored in environment');
+    } else {
+      logFail('Encryption key not stored correctly');
+    }
+
+    if (client.ledger === '--ledger') {
+      logPass('Ledger flag set correctly');
+    } else {
+      logFail('Ledger flag not set correctly');
+    }
+
+    const baseArgs = client._baseArgs();
+    if (baseArgs.includes('--file') && baseArgs.includes('--ledger')) {
+      logPass('Base args include both --file and --ledger flags');
+    } else {
+      logFail('Base args should include both flags');
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+async function testInitializedFlag() {
+  logTest('Initialized flag behavior');
+
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(TEST_DIR);
+
+    const client = new CodexClient();
+
+    if (!client._initialized) {
+      logPass('_initialized flag is false before initialize()');
+    } else {
+      logFail('_initialized flag should be false initially');
+    }
+
+    await client.initialize();
+
+    if (client._initialized) {
+      logPass('_initialized flag is true after initialize()');
+    } else {
+      logFail('_initialized flag should be true after initialize()');
+    }
+
+    // Calling initialize again should not cause issues
+    await client.initialize();
+    logPass('Multiple initialize() calls are safe');
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+// ============================================
+// RUN ALL TESTS
+// ============================================
+
+async function runAllTests() {
+  log('\n═══════════════════════════════════════════════════════', 'yellow');
+  log('  CodexDB SDK - Unit Tests', 'yellow');
+  log('═══════════════════════════════════════════════════════\n', 'yellow');
+
+  await setupTestDir();
+
+  try {
+    await testDefaultDataDirectory();
+    await testCustomFileOption();
+    await testDirectoryCreationOnDemand();
+    await testMultipleLevelsPath();
+    await testClientProperties();
+    await testInitializedFlag();
+
+    log('\n═══════════════════════════════════════════════════════', 'yellow');
+    if (process.exitCode) {
+      log('  Some tests failed!', 'red');
+    } else {
+      log('  All tests passed! ✓', 'green');
+    }
+    log('═══════════════════════════════════════════════════════\n', 'yellow');
+  } finally {
+    await cleanupTestDir();
+  }
+}
+
+// Run tests
+runAllTests().catch((error) => {
+  log(`Fatal error: ${error.message}`, 'red');
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "codexdb-sdk",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Node.js SDK for CodexDB (wrapper around codex-cli)",
   "main": "index.js",
   "scripts": {
     "test": "node test.js",
+    "test:unit": "node index.test.js",
     "postinstall": "node scripts/postinstall.js",
     "publish-check": "node scripts/publish-check.js",
     "release": "bash scripts/publish.sh"

package/scripts/postinstall.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { https } = require('follow-redirects');
+const { execSync } = require('child_process');
+
+// Get package.json path relative to this script
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = require(packageJsonPath);
+const version = packageJson.version;
+
+// Map platform to OS name in release
+const OS_MAP = {
+  darwin: 'darwin',
+  linux: 'linux',
+  win32: 'windows'
+};
+
+// Get system info
+const platform = os.platform();
+const osName = OS_MAP[platform];
+const arch = os.arch() === 'arm64' ? 'arm64' : 'amd64';
+
+if (!osName) {
+  console.log(`⚠️  No binary available for platform: ${platform}`);
+  process.exit(0); // Don't fail, just skip
+}
+
+const dest = path.join(__dirname, '..', 'codex-cli' + (platform === 'win32' ? '.exe' : ''));
+const tempDir = path.join(__dirname, '..', '.temp-extract');
+
+console.log(`Fetching release info for v${version}...`);
+
+// Fetch release information from GitHub API
+const apiUrl = `https://api.github.com/repos/evertonmj/codex/releases/tags/v${version}`;
+
+https.get(apiUrl, {
+  headers: { 'User-Agent': 'codex-postinstall' }
+}, (res) => {
+  let data = '';
+  res.on('data', chunk => { data += chunk; });
+  res.on('end', () => {
+    try {
+      const release = JSON.parse(data);
+      
+      // Check if the API returned an error
+      if (release.message) {
+        console.log(`⚠️  Release v${version} not found on GitHub`);
+        console.log(`   This is normal during development before publishing`);
+        console.log(`   The codex-cli binary will be available after creating a GitHub release`);
+        process.exit(0); // Don't fail, just skip
+      }
+      
+      if (!release.assets || !Array.isArray(release.assets)) {
+        console.log(`⚠️  Invalid release data: no assets found`);
+        process.exit(0); // Don't fail, just skip
+      }
+      
+      // Find the correct binary for this platform/arch
+      const pattern = `codexdb_${version}_${osName}_${arch}`;
+      const asset = release.assets.find(a => a.name.includes(pattern));
+      
+      if (!asset) {
+        console.log(`⚠️  No binary found for ${osName}/${arch}`);
+        console.log(`   Expected pattern: ${pattern}`);
+        console.log(`   Available assets: ${release.assets.map(a => a.name).join(', ')}`);
+        process.exit(0); // Don't fail, just skip
+      }
+
+      console.log(`Downloading ${asset.name}...`);
+      
+      // Create temp directory
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+
+      const tempFile = path.join(tempDir, asset.name);
+      
+      https.get(asset.browser_download_url, (res) => {
+        if (res.statusCode !== 200) {
+          console.log(`⚠️  Failed to download binary: ${res.statusCode}`);
+          process.exit(0); // Don't fail, just skip
+        }
+        const file = fs.createWriteStream(tempFile);
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close(() => {
+            extractAndInstall(tempFile, asset.name, dest, tempDir);
+          });
+        });
+      }).on('error', (err) => {
+        console.log(`⚠️  Download error: ${err.message}`);
+        process.exit(0); // Don't fail, just skip
+      });
+    } catch (err) {
+      console.log(`⚠️  Failed to parse release info: ${err.message}`);
+      process.exit(0); // Don't fail, just skip
+    }
+  });
+}).on('error', (err) => {
+  console.log(`⚠️  API error: ${err.message}`);
+  console.log(`   The codex-cli binary must be downloaded manually or will be installed on first use`);
+  process.exit(0); // Don't fail, just skip
+});
+
+function extractAndInstall(archivePath, archiveName, destPath, tempDir) {
+  try {
+    console.log(`Extracting ${archiveName}...`);
+    
+    if (archiveName.endsWith('.tar.gz')) {
+      execSync(`tar -xzf ${archivePath} -C ${tempDir}`);
+    } else if (archiveName.endsWith('.zip')) {
+      execSync(`unzip -q ${archivePath} -d ${tempDir}`);
+    } else if (archiveName.endsWith('.deb')) {
+      // For .deb files, extract the data
+      execSync(`ar x ${archivePath} data.tar.xz -o ${tempDir}/data.tar.xz`);
+      execSync(`tar -xf ${tempDir}/data.tar.xz -C ${tempDir}`);
+    }
+    
+    // Find the binary in the extracted files
+    const files = execSync(`find ${tempDir} -type f -name 'codex-cli*' -o -name 'codexdb' 2>/dev/null`, { encoding: 'utf-8' }).trim().split('\n').filter(f => f);
+    
+    if (files.length === 0) {
+      console.log('⚠️  Binary not found in archive');
+      process.exit(0); // Don't fail, just skip
+    }
+    
+    const binaryPath = files[0];
+    fs.copyFileSync(binaryPath, destPath);
+    fs.chmodSync(destPath, 0o755);
+    
+    // Cleanup
+    execSync(`rm -rf ${tempDir}`);
+    
+    console.log('✓ codex-cli installed to', destPath);
+    process.exit(0);
+  } catch (err) {
+    console.log(`⚠️  Extraction error: ${err.message}`);
+    process.exit(0); // Don't fail, just skip
+  }
+}