@cerulin/chell 0.2.5

package/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@cerulin/chell",
+  "version": "0.2.5",
+  "description": "Mobile and Web client for Claude Code and Codex",
+  "author": "Cerulin",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/cerulin/chell-cli",
+  "bugs": "https://github.com/cerulin/chell-cli/issues",
+  "repository": "cerulin/chell-cli",
+  "bin": {
+    "happy": "./bin/chell.mjs",
+    "happy-mcp": "./bin/chell-mcp.mjs",
+    "chell": "./bin/chell.mjs",
+    "chell-mcp": "./bin/chell-mcp.mjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./lib": {
+      "require": {
+        "types": "./dist/lib.d.cts",
+        "default": "./dist/lib.cjs"
+      },
+      "import": {
+        "types": "./dist/lib.d.mts",
+        "default": "./dist/lib.mjs"
+      }
+    },
+    "./codex/chellMcpStdioBridge": {
+      "require": {
+        "types": "./dist/codex/chellMcpStdioBridge.d.cts",
+        "default": "./dist/codex/chellMcpStdioBridge.cjs"
+      },
+      "import": {
+        "types": "./dist/codex/chellMcpStdioBridge.d.mts",
+        "default": "./dist/codex/chellMcpStdioBridge.mjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "scripts",
+    "tools",
+    "package.json"
+  ],
+  "scripts": {
+    "why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
+    "typecheck": "tsc --noEmit",
+    "build": "shx rm -rf dist && npx tsc --noEmit && pkgroll",
+    "obfuscate": "shx rm -rf dist.obf && javascript-obfuscator dist --output dist.obf --compact true --self-defending false --control-flow-flattening true --string-array true --string-array-encoding base64 --identifier-names-generator mangled && shx cp -r dist/*.d.* dist.obf 2>nul && shx rm -rf dist && shx mv dist.obf dist",
+    "build:obf": "yarn build && yarn obfuscate",
+    "pack:chell": "node scripts/pack-chell.cjs",
+    "test": "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
+    "start": "yarn build && ./bin/chell.mjs",
+    "dev": "yarn build && tsx --env-file .env.dev src/index.ts",
+    "dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+    "dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
+    "prepublishOnly": "yarn build && yarn test",
+    "release": "release-it",
+    "postinstall": "node scripts/unpack-tools.cjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-code": "^2.0.14",
+    "@anthropic-ai/sdk": "^0.56.0",
+    "@modelcontextprotocol/sdk": "^1.15.1",
+    "@openai/codex": "^0.50.0",
+    "@stablelib/base64": "^2.0.1",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/http-proxy": "^1.17.16",
+    "@types/ps-list": "^6.2.1",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/react": "^19.1.9",
+    "axios": "^1.10.0",
+    "chalk": "^5.4.1",
+    "chell": "^1.0.4",
+    "cross-spawn": "^7.0.6",
+    "expo-server-sdk": "^3.15.0",
+    "fastify": "^5.5.0",
+    "fastify-type-provider-zod": "4.0.2",
+    "http-proxy": "^1.18.1",
+    "http-proxy-middleware": "^3.0.5",
+    "ink": "^6.1.0",
+    "node-pty": "1.0.0",
+    "open": "^10.2.0",
+    "ps-list": "^8.1.1",
+    "qrcode-terminal": "^0.12.0",
+    "react": "^19.1.1",
+    "socket.io-client": "^4.8.1",
+    "tar": "^7.4.3",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1",
+    "@types/node": ">=20",
+    "cross-env": "^10.0.0",
+    "dotenv": "^16.6.1",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10",
+    "javascript-obfuscator": "4",
+    "pkgroll": "^2.14.2",
+    "release-it": "^19.0.4",
+    "shx": "^0.3.3",
+    "ts-node": "^10",
+    "tsx": "^4.20.3",
+    "typescript": "^5",
+    "vitest": "^3.2.4"
+  },
+  "resolutions": {
+    "whatwg-url": "14.2.0",
+    "parse-path": "7.0.3",
+    "@types/parse-path": "7.0.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "packageManager": "yarn@1.22.22"
+}

package/scripts/claude_local_launcher.cjs

@@ -0,0 +1,98 @@
+const crypto = require('crypto');
+const fs = require('fs');
+
+// Disable autoupdater (never works really)
+process.env.DISABLE_AUTOUPDATER = '1';
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+    try {
+        fs.writeSync(3, JSON.stringify(message) + '\n');
+    } catch (err) {
+        // fd 3 not available, ignore
+    }
+}
+
+// Intercept crypto.randomUUID
+const originalRandomUUID = crypto.randomUUID;
+Object.defineProperty(global, 'crypto', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return {
+            randomUUID: () => {
+                const uuid = originalRandomUUID();
+                writeMessage({ type: 'uuid', value: uuid });
+                return uuid;
+            }
+        };
+    }
+});
+Object.defineProperty(crypto, 'randomUUID', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return () => {
+            const uuid = originalRandomUUID();
+            writeMessage({ type: 'uuid', value: uuid });
+            return uuid;
+        }
+    }
+});
+
+// Intercept fetch to track activity
+const originalFetch = global.fetch;
+let fetchCounter = 0;
+
+global.fetch = function(...args) {
+    const id = ++fetchCounter;
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const method = args[1]?.method || 'GET';
+    
+    // Parse URL for privacy
+    let hostname = '';
+    let path = '';
+    try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        path = urlObj.pathname;
+    } catch (e) {
+        // If URL parsing fails, use defaults
+        hostname = 'unknown';
+        path = url;
+    }
+    
+    // Send fetch start event
+    writeMessage({
+        type: 'fetch-start',
+        id,
+        hostname,
+        path,
+        method,
+        timestamp: Date.now()
+    });
+
+    // Execute the original fetch immediately
+    const fetchPromise = originalFetch(...args);
+    
+    // Attach handlers to send fetch end event
+    const sendEnd = () => {
+        writeMessage({
+            type: 'fetch-end',
+            id,
+            timestamp: Date.now()
+        });
+    };
+    
+    // Send end event on both success and failure
+    fetchPromise.then(sendEnd, sendEnd);
+    
+    // Return the original promise unchanged
+    return fetchPromise;
+};
+
+// Preserve fetch properties
+Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
+
+import('@anthropic-ai/claude-code/cli.js')

package/scripts/claude_remote_launcher.cjs

@@ -0,0 +1,13 @@
+// Intercept setTimeout for the Claude Code SDK
+const originalSetTimeout = global.setTimeout;
+
+global.setTimeout = function(callback, delay, ...args) {
+    // Just wrap and call the original setTimeout
+    return originalSetTimeout(callback, delay, ...args);
+};
+
+// Preserve setTimeout properties
+Object.defineProperty(global.setTimeout, 'name', { value: 'setTimeout' });
+Object.defineProperty(global.setTimeout, 'length', { value: originalSetTimeout.length });
+
+import('@anthropic-ai/claude-code/cli.js')

package/scripts/codex_local_launcher.cjs

@@ -0,0 +1,155 @@
+const crypto = require('crypto');
+const fs = require('fs');
+
+// Disable autoupdater if Codex has one
+process.env.DISABLE_AUTOUPDATER = '1';
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+    try {
+        fs.writeSync(3, JSON.stringify(message) + '\n');
+    } catch (err) {
+        // fd 3 not available, ignore
+    }
+}
+
+// Intercept crypto.randomUUID
+const originalRandomUUID = crypto.randomUUID;
+Object.defineProperty(global, 'crypto', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return {
+            randomUUID: () => {
+                const uuid = originalRandomUUID();
+                writeMessage({ type: 'uuid', value: uuid });
+                return uuid;
+            }
+        };
+    }
+});
+Object.defineProperty(crypto, 'randomUUID', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return () => {
+            const uuid = originalRandomUUID();
+            writeMessage({ type: 'uuid', value: uuid });
+            return uuid;
+        }
+    }
+});
+
+// Intercept fetch to track activity
+const originalFetch = global.fetch;
+let fetchCounter = 0;
+
+global.fetch = function(...args) {
+    const id = ++fetchCounter;
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const method = args[1]?.method || 'GET';
+    
+    // Parse URL for privacy
+    let hostname = '';
+    let path = '';
+    try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        path = urlObj.pathname;
+    } catch (e) {
+        // If URL parsing fails, use defaults
+        hostname = 'unknown';
+        path = url;
+    }
+    
+    // Send fetch start event
+    writeMessage({
+        type: 'fetch-start',
+        id,
+        hostname,
+        path,
+        method,
+        timestamp: Date.now()
+    });
+
+    // Execute the original fetch immediately
+    const fetchPromise = originalFetch(...args);
+    
+    // Attach handlers to send fetch end event
+    const sendEnd = () => {
+        writeMessage({
+            type: 'fetch-end',
+            id,
+            timestamp: Date.now()
+        });
+    };
+    
+    // Send end event on both success and failure
+    fetchPromise.then(sendEnd, sendEnd);
+    
+    // Return the original promise unchanged
+    return fetchPromise;
+};
+
+// Preserve fetch properties
+Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
+
+// Log startup to fd3
+writeMessage({ type: 'launcher_start', timestamp: Date.now() });
+
+// Import Codex CLI
+// Try different entry points based on how OpenAI packages Codex
+(async () => {
+    try {
+        // Try with .js extension first (Node ESM requires explicit extensions)
+        writeMessage({ type: 'import_attempt', path: '@openai/codex/bin/codex.js' });
+        await import('@openai/codex/bin/codex.js');
+        writeMessage({ type: 'import_success', path: '@openai/codex/bin/codex.js' });
+    } catch (err1) {
+        try {
+            // Try CLI entry point
+            writeMessage({ type: 'import_attempt', path: '@openai/codex/cli.js' });
+            await import('@openai/codex/cli.js');
+            writeMessage({ type: 'import_success', path: '@openai/codex/cli.js' });
+        } catch (err2) {
+            try {
+                // Try main export
+                writeMessage({ type: 'import_attempt', path: '@openai/codex' });
+                await import('@openai/codex');
+                writeMessage({ type: 'import_success', path: '@openai/codex' });
+            } catch (err3) {
+                try {
+                    // Try bin without extension (for older Node versions)
+                    writeMessage({ type: 'import_attempt', path: '@openai/codex/bin/codex' });
+                    await import('@openai/codex/bin/codex');
+                    writeMessage({ type: 'import_success', path: '@openai/codex/bin/codex' });
+                } catch (err4) {
+                    try {
+                        // Try dist/bin/codex.js (common build output location)
+                        writeMessage({ type: 'import_attempt', path: '@openai/codex/dist/bin/codex.js' });
+                        await import('@openai/codex/dist/bin/codex.js');
+                        writeMessage({ type: 'import_success', path: '@openai/codex/dist/bin/codex.js' });
+                    } catch (err5) {
+                        writeMessage({ type: 'import_failed', error: err5.message });
+                        console.error('❌ Failed to load Codex CLI from any known entry point');
+                        console.error('Attempted paths:');
+                        console.error('  - @openai/codex/bin/codex.js');
+                        console.error('  - @openai/codex/cli.js');
+                        console.error('  - @openai/codex');
+                        console.error('  - @openai/codex/bin/codex');
+                        console.error('  - @openai/codex/dist/bin/codex.js');
+                        console.error('');
+                        console.error('Last error:', err5.message);
+                        console.error('');
+                        console.error('This is likely a bundling issue. The @openai/codex package should be');
+                        console.error('included in chell dependencies and bundled during npm pack.');
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+    }
+})();
+
+

package/scripts/codex_preload.cjs

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const crypto = require('crypto');
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+  try {
+    fs.writeSync(3, JSON.stringify(message) + '\n');
+  } catch (_) {
+    // fd3 not available; ignore
+  }
+}
+
+// Log preload activation
+writeMessage({ type: 'launcher_start', timestamp: Date.now(), preload: true });
+
+// Intercept crypto.randomUUID to surface session UUIDs
+try {
+  const originalRandomUUID = crypto.randomUUID;
+  Object.defineProperty(crypto, 'randomUUID', {
+    configurable: true,
+    enumerable: true,
+    value: () => {
+      const uuid = originalRandomUUID();
+      writeMessage({ type: 'uuid', value: uuid });
+      return uuid;
+    }
+  });
+} catch (_) {}
+
+// Intercept global.fetch to track thinking
+try {
+  const originalFetch = global.fetch;
+  if (typeof originalFetch === 'function') {
+    let fetchCounter = 0;
+    global.fetch = function(...args) {
+      const id = ++fetchCounter;
+      const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+      let hostname = '';
+      let path = '';
+      try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        path = urlObj.pathname;
+      } catch {}
+      writeMessage({ type: 'fetch-start', id, hostname, path, timestamp: Date.now() });
+      const p = originalFetch.apply(this, args);
+      const sendEnd = () => writeMessage({ type: 'fetch-end', id, timestamp: Date.now() });
+      p.then(sendEnd, sendEnd);
+      return p;
+    }
+  }
+} catch (_) {}
+
+// Disable any autoupdater behavior in codex if present
+process.env.DISABLE_AUTOUPDATER = '1';
+

package/scripts/codex_remote_launcher.cjs

@@ -0,0 +1,129 @@
+const crypto = require('crypto');
+const fs = require('fs');
+
+// Disable autoupdater if Codex has one
+process.env.DISABLE_AUTOUPDATER = '1';
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+    try {
+        fs.writeSync(3, JSON.stringify(message) + '\n');
+    } catch (err) {
+        // fd 3 not available, ignore
+    }
+}
+
+// Intercept crypto.randomUUID
+const originalRandomUUID = crypto.randomUUID;
+Object.defineProperty(global, 'crypto', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return {
+            randomUUID: () => {
+                const uuid = originalRandomUUID();
+                writeMessage({ type: 'uuid', value: uuid });
+                return uuid;
+            }
+        };
+    }
+});
+Object.defineProperty(crypto, 'randomUUID', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return () => {
+            const uuid = originalRandomUUID();
+            writeMessage({ type: 'uuid', value: uuid });
+            return uuid;
+        }
+    }
+});
+
+// Intercept fetch to track activity
+const originalFetch = global.fetch;
+let fetchCounter = 0;
+
+global.fetch = function(...args) {
+    const id = ++fetchCounter;
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const method = args[1]?.method || 'GET';
+    
+    // Parse URL for privacy
+    let hostname = '';
+    let path = '';
+    try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        path = urlObj.pathname;
+    } catch (e) {
+        // If URL parsing fails, use defaults
+        hostname = 'unknown';
+        path = url;
+    }
+    
+    // Send fetch start event
+    writeMessage({
+        type: 'fetch-start',
+        id,
+        hostname,
+        path,
+        method,
+        timestamp: Date.now()
+    });
+
+    // Execute the original fetch immediately
+    const fetchPromise = originalFetch(...args);
+    
+    // Attach handlers to send fetch end event
+    const sendEnd = () => {
+        writeMessage({
+            type: 'fetch-end',
+            id,
+            timestamp: Date.now()
+        });
+    };
+    
+    // Send end event on both success and failure
+    fetchPromise.then(sendEnd, sendEnd);
+    
+    // Return the original promise unchanged
+    return fetchPromise;
+};
+
+// Preserve fetch properties
+Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
+
+// Import Codex SDK for remote control
+// Try different entry points based on how OpenAI packages Codex
+(async () => {
+    try {
+        // Try SDK entry point first (for remote/programmatic control)
+        await import('@openai/codex/sdk.js');
+    } catch (err1) {
+        try {
+            // Try CLI as fallback (can also be used remotely)
+            await import('@openai/codex/cli.js');
+        } catch (err2) {
+            try {
+                // Try main export
+                await import('@openai/codex');
+            } catch (err3) {
+                console.error('❌ Failed to load Codex from any known entry point');
+                console.error('Attempted paths:');
+                console.error('  - @openai/codex/sdk.js');
+                console.error('  - @openai/codex/cli.js');
+                console.error('  - @openai/codex');
+                console.error('');
+                console.error('Error details:', err3.message);
+                console.error('');
+                console.error('Please ensure @openai/codex is installed correctly:');
+                console.error('  npm install @openai/codex');
+                console.error('  or check https://github.com/openai/codex for installation instructions');
+                process.exit(1);
+            }
+        }
+    }
+})();
+

package/scripts/obfuscate-dist.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join, relative, extname, basename } from 'path';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, copyFileSync } from 'fs';
+import JavaScriptObfuscator from 'javascript-obfuscator';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = join(__dirname, '..');
+const distDir = join(rootDir, 'dist');
+const distObfDir = join(rootDir, 'dist.obf');
+
+const obfuscatorOptions = {
+  compact: true,
+  selfDefending: false,
+  controlFlowFlattening: true,
+  stringArray: true,
+  stringArrayEncoding: ['base64'],
+  identifierNamesGenerator: 'mangled'
+};
+
+function getAllFiles(dir, fileList = []) {
+  const files = readdirSync(dir);
+
+  files.forEach(file => {
+    const filePath = join(dir, file);
+    if (statSync(filePath).isDirectory()) {
+      getAllFiles(filePath, fileList);
+    } else {
+      fileList.push(filePath);
+    }
+  });
+
+  return fileList;
+}
+
+function obfuscateFile(inputPath, outputPath) {
+  const ext = extname(inputPath);
+
+  // Only obfuscate .cjs and .mjs files
+  if (ext === '.cjs' || ext === '.mjs') {
+    console.log(`Obfuscating: ${relative(rootDir, inputPath)}`);
+    const code = readFileSync(inputPath, 'utf8');
+    const obfuscated = JavaScriptObfuscator.obfuscate(code, obfuscatorOptions);
+
+    // Create output directory if it doesn't exist
+    const outputDir = dirname(outputPath);
+    mkdirSync(outputDir, { recursive: true });
+
+    writeFileSync(outputPath, obfuscated.getObfuscatedCode(), 'utf8');
+  } else {
+    // Copy type definition files and other files as-is
+    console.log(`Copying: ${relative(rootDir, inputPath)}`);
+    const outputDir = dirname(outputPath);
+    mkdirSync(outputDir, { recursive: true });
+    copyFileSync(inputPath, outputPath);
+  }
+}
+
+console.log('Starting obfuscation...');
+
+// Get all files from dist
+const allFiles = getAllFiles(distDir);
+
+// Process each file
+allFiles.forEach(inputPath => {
+  const relativePath = relative(distDir, inputPath);
+  const outputPath = join(distObfDir, relativePath);
+  obfuscateFile(inputPath, outputPath);
+});
+
+console.log(`Obfuscation complete! Output in ${relative(rootDir, distObfDir)}`);

package/scripts/pack-chell.cjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+const { execSync } = require('node:child_process');
+const { existsSync, unlinkSync, renameSync } = require('node:fs');
+const { join } = require('node:path');
+
+try {
+  const outName = 'chell.tgz';
+  const outPath = join(process.cwd(), outName);
+
+  if (existsSync(outPath)) {
+    unlinkSync(outPath);
+  }
+
+  // Run npm pack and capture the produced filename
+  const result = execSync('npm pack --silent', { stdio: ['ignore', 'pipe', 'inherit'] })
+    .toString()
+    .trim();
+
+  if (!result || !result.endsWith('.tgz')) {
+    console.error('Failed to determine pack filename, got:', result);
+    process.exit(1);
+  }
+
+  // Rename to chell.tgz
+  renameSync(join(process.cwd(), result), outPath);
+  console.log(`Created ${outName}`);
+} catch (err) {
+  console.error('pack-chell failed:', err?.message || err);
+  process.exit(1);
+}
+
+