replit-tools 1.0.1 → 1.0.3

package/README.md

@@ -1,46 +1,52 @@
-# replit-claude-persist
+# DATA Tools
 
-**Persist Claude Code sessions, authentication, and history across Replit container restarts.**
+**One command to set up Claude Code and Codex CLI on Replit with full persistence.**
 
-When Replit containers restart, everything outside `/home/runner/workspace/` is wiped - including your Claude conversations, auth tokens, and installed binaries. This tool fixes that.
+When Replit containers restart, everything outside `/home/runner/workspace/` is wiped - including installed CLIs, conversations, auth tokens, and command history. DATA Tools fixes all of that.
 
-## Features
+## Quick Start
 
-- **Session Persistence** - Conversations survive container restarts
-- **Interactive Session Picker** - Choose which session to resume on shell start
-- **Multi-Terminal Support** - Each terminal tracks its own session
-- **Auth Persistence** - Keep your Claude authentication working
-- **Binary Caching** - Claude binary persists (faster startup)
-- **Bash History** - Command history survives restarts too
+```bash
+npx replit-tools
+```
 
-## Installation
+That's it. The installer will:
 
-### Option 1: npx (easiest)
+1. **Install Claude Code** (if not already installed)
+2. **Install OpenAI Codex CLI** (if not already installed)
+3. **Detect existing config** and preserve your data
+4. **Set up persistence** so everything survives restarts
+5. **Launch the session picker** so you can start working immediately
 
-```bash
-npx replit-claude-persist
-```
+## What Gets Installed
 
-### Option 2: curl
+| Tool | Source | Purpose |
+|------|--------|---------|
+| **Claude Code** | `curl https://claude.ai/install.sh` | Anthropic's CLI for Claude |
+| **Codex CLI** | `npm i -g @openai/codex` | OpenAI's coding assistant |
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/stevemoraco/DATAtools/main/install.sh | bash
-```
+Both are installed only if not already present. Existing installations are preserved.
 
-### Option 3: Manual
+## What Gets Persisted
 
-```bash
-npm install -g replit-claude-persist
-replit-claude-persist
-```
+| Data | Location | Survives Restart? |
+|------|----------|-------------------|
+| Claude conversations | `.claude-persistent/` | Yes |
+| Claude credentials | `.claude-persistent/` | Yes |
+| Claude binary | `.local/share/claude/versions/` | Yes |
+| Codex data | `.codex-persistent/` | Yes |
+| Bash history | `.persistent-home/` | Yes |
+| Per-terminal sessions | `.claude-sessions/` | Yes |
 
-## What You'll See
+## The Session Picker
 
-After installation, opening a new shell shows:
+After installation (and on every new shell), you'll see:
 
 ```
+✅ Claude Code already installed (1.0.17)
+✅ Codex CLI already installed
+
 ✅ Claude authentication: valid (23h remaining)
-✅ Claude Code ready: 2.0.71 (Claude Code)
 
 ╭─────────────────────────────────────────────────────────╮
 │  Claude Session Manager                                 │
@@ -56,7 +62,9 @@ After installation, opening a new shell shows:
   Choice [c/r/n/s]: _
 ```
 
-Press `r` to see detailed session info:
+### Session Details
+
+Press `r` to see full session metadata:
 
 ```
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -69,30 +77,85 @@ Press `r` to see detailed session info:
   Latest:   "Thanks, that worked!"
 ```
 
+Each session shows:
+- Full UUID
+- Message count and file size
+- Time since last activity
+- Start and last activity timestamps
+- First and latest prompts (truncated)
+
+## Multi-Terminal Support
+
+Each terminal tracks its own session independently:
+
+```
+Terminal pts/0 → Session abc123... (your migration work)
+Terminal pts/1 → Session def456... (your docs work)
+Terminal pts/2 → Session ghi789... (your debugging)
+```
+
+Press `c` to continue YOUR terminal's last session. Other terminals are unaffected.
+
 ## How It Works
 
-The tool creates symlinks from ephemeral locations to persistent workspace storage:
+The installer creates symlinks from ephemeral locations to persistent workspace storage:
+
+```
+~/.claude           →  /workspace/.claude-persistent/
+~/.codex            →  /workspace/.codex-persistent/
+~/.local/share/claude →  /workspace/.local/share/claude/
+~/.local/bin/claude →  /workspace/.local/share/claude/versions/X.X.X
+```
+
+Three layers ensure setup runs on every restart:
+1. `.replit` onBoot hook (runs at container boot)
+2. `.config/bashrc` (runs on every shell start)
+3. Scripts in `workspace/scripts/` (called by above)
+
+## Smart Detection
+
+The installer checks for:
+
+- **Existing persistent config** - Uses your existing `.claude-persistent/` if present
+- **Replit Secrets** - Detects `ANTHROPIC_API_KEY` and `OPENAI_API_KEY`
+- **Existing installations** - Won't reinstall Claude or Codex if already present
+- **Existing data in ~/.claude** - Moves it to persistent storage instead of overwriting
 
+## Installation Options
+
+### Option 1: npx (recommended)
+
+```bash
+npx replit-tools
 ```
-~/.claude      →  /workspace/.claude-persistent/
-~/.codex       →  /workspace/.codex-persistent/
-~/.local/bin/  →  /workspace/.local/share/claude/versions/
+
+### Option 2: curl
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/stevemoraco/DATAtools/main/install.sh | bash
 ```
 
-On every shell start, `.config/bashrc` ensures symlinks exist and shows the session picker.
+### Option 3: Global install
+
+```bash
+npm install -g replit-tools
+replit-tools
+```
 
 ## Commands
 
+After installation, these aliases are available:
+
 | Command | Description |
 |---------|-------------|
-| `cr` | Continue last session |
-| `claude-menu` | Show session picker again |
-| `claude-new` | Start fresh session |
-| `claude-pick` | Claude's built-in picker |
+| `cr` | Continue last Claude session |
+| `claude-resume` | Same as `cr` |
+| `claude-pick` | Claude's built-in session picker |
+| `claude-menu` | Show the session manager menu again |
 
 ## Configuration
 
-### Disable the menu
+### Disable the session picker menu
 
 ```bash
 export CLAUDE_NO_PROMPT=true
@@ -100,32 +163,39 @@ export CLAUDE_NO_PROMPT=true
 
 Add to `.config/bashrc` to make permanent.
 
-### Fix auth permanently
+### Fix authentication permanently
 
 ```bash
 claude setup-token
 ```
 
-Creates a long-lived token that doesn't expire.
+Creates a long-lived API token that doesn't expire (OAuth tokens expire every ~24h).
 
 ## Files Created
 
 ```
 workspace/
-├── .claude-persistent/     # Conversations, credentials
+├── .claude-persistent/     # Claude conversations & credentials
 ├── .codex-persistent/      # Codex CLI data
 ├── .claude-sessions/       # Per-terminal session tracking
 ├── .local/share/claude/    # Claude binary versions
 ├── .persistent-home/       # Bash history
 ├── .config/bashrc          # Shell startup config
-└── scripts/
-    ├── setup-claude-code.sh
-    └── claude-session-manager.sh
+├── scripts/
+│   ├── setup-claude-code.sh
+│   └── claude-session-manager.sh
+└── .gitignore              # Updated to ignore credential dirs
 ```
 
 ## Troubleshooting
 
-### Menu not appearing
+### Claude or Codex not found after restart
+
+```bash
+source /home/runner/workspace/scripts/setup-claude-code.sh
+```
+
+### Session picker not appearing
 
 ```bash
 source /home/runner/workspace/.config/bashrc
@@ -142,9 +212,27 @@ claude setup-token
 ### Symlinks broken
 
 ```bash
-source /home/runner/workspace/scripts/setup-claude-code.sh
+npx replit-tools
 ```
 
+Running the installer again is safe - it preserves existing data.
+
+## Security
+
+The installer adds these to `.gitignore`:
+- `.claude-persistent/` (contains credentials)
+- `.codex-persistent/` (contains credentials)
+
+Your API keys and conversation history won't be committed to git.
+
+## Why "DATA Tools"?
+
+**D**eveloper **A**ssistant **T**ool **A**utomation - everything you need to run AI coding assistants on Replit, persisted and ready to go.
+
+## Repository
+
+GitHub: [stevemoraco/DATAtools](https://github.com/stevemoraco/DATAtools)
+
 ## License
 
 MIT

package/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
-const { execSync, spawn } = require('child_process');
+const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 const WORKSPACE = '/home/runner/workspace';
+const HOME = os.homedir();
 
 // Check if we're on Replit
 if (!fs.existsSync(WORKSPACE)) {
@@ -15,11 +17,45 @@ if (!fs.existsSync(WORKSPACE)) {
 
 console.log('');
 console.log('╭─────────────────────────────────────────────────────────╮');
-console.log('│  Replit Claude Persistence Installer                    │');
+console.log('│  Replit Tools - Claude & Codex Persistence             │');
 console.log('╰─────────────────────────────────────────────────────────╯');
 console.log('');
 
-// Create directories
+// Helper to check if command exists
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Helper to check for Replit secret
+function hasReplitSecret(name) {
+  return process.env[name] !== undefined;
+}
+
+// Check for existing persistent config
+const existingClaudeConfig = fs.existsSync(path.join(WORKSPACE, '.claude-persistent'));
+const existingCodexConfig = fs.existsSync(path.join(WORKSPACE, '.codex-persistent'));
+
+if (existingClaudeConfig) {
+  console.log('✅ Found existing Claude config in workspace');
+}
+if (existingCodexConfig) {
+  console.log('✅ Found existing Codex config in workspace');
+}
+
+// Check for Replit secrets
+if (hasReplitSecret('ANTHROPIC_API_KEY')) {
+  console.log('✅ Found ANTHROPIC_API_KEY in Replit secrets');
+}
+if (hasReplitSecret('OPENAI_API_KEY')) {
+  console.log('✅ Found OPENAI_API_KEY in Replit secrets');
+}
+
+// Create directories (preserving existing data)
 const dirs = [
   '.claude-persistent',
   '.codex-persistent',
@@ -31,6 +67,7 @@ const dirs = [
   'logs'
 ];
 
+console.log('');
 console.log('📁 Creating directories...');
 dirs.forEach(dir => {
   const fullPath = path.join(WORKSPACE, dir);
@@ -39,13 +76,146 @@ dirs.forEach(dir => {
   }
 });
 
+// Check and install Claude Code if needed
+console.log('');
+const claudeInstalled = commandExists('claude') ||
+  fs.existsSync(path.join(HOME, '.local/bin/claude')) ||
+  fs.existsSync(path.join(WORKSPACE, '.local/share/claude/versions'));
+
+let claudeVersions = [];
+try {
+  claudeVersions = fs.readdirSync(path.join(WORKSPACE, '.local/share/claude/versions'));
+} catch {}
+
+if (!claudeInstalled || claudeVersions.length === 0) {
+  console.log('📦 Installing Claude Code...');
+  try {
+    execSync('curl -fsSL https://claude.ai/install.sh | bash', {
+      stdio: 'inherit',
+      shell: '/bin/bash'
+    });
+    console.log('✅ Claude Code installed');
+  } catch (err) {
+    console.log('⚠️  Claude Code installation failed (you can install manually later)');
+  }
+} else {
+  const version = claudeVersions.sort().pop() || 'unknown';
+  console.log(`✅ Claude Code already installed (${version})`);
+}
+
+// Check and install Codex if needed
+const codexInstalled = commandExists('codex');
+
+if (!codexInstalled) {
+  console.log('📦 Installing OpenAI Codex CLI...');
+  try {
+    execSync('npm i -g @openai/codex', {
+      stdio: 'inherit',
+      shell: '/bin/bash'
+    });
+    console.log('✅ Codex CLI installed');
+  } catch (err) {
+    console.log('⚠️  Codex installation failed (you can install manually later)');
+  }
+} else {
+  console.log('✅ Codex CLI already installed');
+}
+
+// Set up symlinks
+console.log('');
+console.log('🔗 Setting up symlinks...');
+
+// Claude symlink
+const claudeTarget = path.join(WORKSPACE, '.claude-persistent');
+const claudeLink = path.join(HOME, '.claude');
+try {
+  const stat = fs.lstatSync(claudeLink);
+  if (stat.isSymbolicLink()) {
+    const current = fs.readlinkSync(claudeLink);
+    if (current !== claudeTarget) {
+      fs.unlinkSync(claudeLink);
+      fs.symlinkSync(claudeTarget, claudeLink);
+    }
+  } else if (stat.isDirectory()) {
+    // Move existing data to persistent location
+    console.log('   Moving existing ~/.claude data to persistent storage...');
+    execSync(`cp -rn ${claudeLink}/* ${claudeTarget}/ 2>/dev/null || true`, { shell: '/bin/bash' });
+    execSync(`rm -rf ${claudeLink}`, { shell: '/bin/bash' });
+    fs.symlinkSync(claudeTarget, claudeLink);
+  }
+} catch {
+  // Doesn't exist, create it
+  fs.symlinkSync(claudeTarget, claudeLink);
+}
+console.log('   ~/.claude → .claude-persistent/');
+
+// Codex symlink
+const codexTarget = path.join(WORKSPACE, '.codex-persistent');
+const codexLink = path.join(HOME, '.codex');
+try {
+  const stat = fs.lstatSync(codexLink);
+  if (stat.isSymbolicLink()) {
+    const current = fs.readlinkSync(codexLink);
+    if (current !== codexTarget) {
+      fs.unlinkSync(codexLink);
+      fs.symlinkSync(codexTarget, codexLink);
+    }
+  } else if (stat.isDirectory()) {
+    console.log('   Moving existing ~/.codex data to persistent storage...');
+    execSync(`cp -rn ${codexLink}/* ${codexTarget}/ 2>/dev/null || true`, { shell: '/bin/bash' });
+    execSync(`rm -rf ${codexLink}`, { shell: '/bin/bash' });
+    fs.symlinkSync(codexTarget, codexLink);
+  }
+} catch {
+  fs.symlinkSync(codexTarget, codexLink);
+}
+console.log('   ~/.codex → .codex-persistent/');
+
+// Claude binary symlinks
+const localBin = path.join(HOME, '.local/bin');
+const localShare = path.join(HOME, '.local/share');
+const claudeShareTarget = path.join(WORKSPACE, '.local/share/claude');
+
+try { fs.mkdirSync(localBin, { recursive: true }); } catch {}
+try { fs.mkdirSync(localShare, { recursive: true }); } catch {}
+
+// Link .local/share/claude
+try {
+  const stat = fs.lstatSync(path.join(localShare, 'claude'));
+  if (stat.isSymbolicLink()) {
+    const current = fs.readlinkSync(path.join(localShare, 'claude'));
+    if (current !== claudeShareTarget) {
+      fs.unlinkSync(path.join(localShare, 'claude'));
+      fs.symlinkSync(claudeShareTarget, path.join(localShare, 'claude'));
+    }
+  }
+} catch {
+  try {
+    fs.symlinkSync(claudeShareTarget, path.join(localShare, 'claude'));
+  } catch {}
+}
+console.log('   ~/.local/share/claude → .local/share/claude/');
+
+// Link binary to latest version
+try {
+  const versions = fs.readdirSync(path.join(WORKSPACE, '.local/share/claude/versions')).sort();
+  if (versions.length > 0) {
+    const latest = versions[versions.length - 1];
+    const binaryPath = path.join(WORKSPACE, '.local/share/claude/versions', latest);
+    const binLink = path.join(localBin, 'claude');
+    try { fs.unlinkSync(binLink); } catch {}
+    fs.symlinkSync(binaryPath, binLink);
+    console.log(`   ~/.local/bin/claude → versions/${latest}`);
+  }
+} catch {}
+
 // Copy scripts from the package
 const scriptsDir = path.join(__dirname, 'scripts');
 const targetScriptsDir = path.join(WORKSPACE, 'scripts');
 
+console.log('');
 console.log('📝 Installing scripts...');
 
-// Read and write each script
 const scripts = ['setup-claude-code.sh', 'claude-session-manager.sh'];
 scripts.forEach(script => {
   const srcPath = path.join(scriptsDir, script);
@@ -54,10 +224,12 @@ scripts.forEach(script => {
   if (fs.existsSync(srcPath)) {
     fs.copyFileSync(srcPath, destPath);
     fs.chmodSync(destPath, '755');
+    console.log(`   ${script}`);
   }
 });
 
 // Create/update .config/bashrc
+console.log('');
 console.log('📝 Creating .config/bashrc...');
 const bashrcContent = `#!/bin/bash
 # Replit Claude Persistence - Auto-generated bashrc
@@ -121,23 +293,41 @@ if (fs.existsSync(gitignorePath)) {
   fs.writeFileSync(gitignorePath, gitignoreEntries.trim() + '\n');
 }
 
+// Add PATH to current process for session manager
+process.env.PATH = `${localBin}:${process.env.PATH}`;
+
 console.log('');
-console.log('✅ Installation complete!');
-console.log('');
-console.log('What happens now:');
-console.log('  • New shells will show the Claude session picker');
-console.log('  • Your conversations persist across container restarts');
-console.log('  • Claude binary is cached (faster startup)');
-console.log('  • Bash history is preserved');
-console.log('');
-console.log('To test, open a new shell or run:');
-console.log('  source ~/.config/bashrc');
+console.log('╭─────────────────────────────────────────────────────────╮');
+console.log('│  ✅ Installation complete!                              │');
+console.log('╰─────────────────────────────────────────────────────────╯');
 console.log('');
-console.log('Options:');
-console.log("  Press 'c' - Continue last session");
-console.log("  Press 'r' - Pick from session list");
-console.log("  Press 'n' - New session");
-console.log("  Press 's' - Skip (just a shell)");
+console.log('Your conversations and credentials now persist across restarts.');
 console.log('');
-console.log('To disable the menu: export CLAUDE_NO_PROMPT=true');
+
+// Check if Claude needs login
+let needsLogin = true;
+try {
+  const authCheck = execSync('claude auth status 2>&1 || true', { encoding: 'utf8', shell: '/bin/bash' });
+  if (authCheck.includes('Logged in') || authCheck.includes('valid')) {
+    needsLogin = false;
+  }
+} catch {}
+
+if (needsLogin && !hasReplitSecret('ANTHROPIC_API_KEY')) {
+  console.log('⚠️  Claude needs authentication. Run: claude login');
+  console.log('');
+}
+
+// Launch the session picker
+console.log('Launching session manager...');
 console.log('');
+
+// Use spawn to run bash interactively with our session manager
+const sessionManager = spawn('bash', ['--rcfile', path.join(WORKSPACE, '.config/bashrc'), '-i'], {
+  stdio: 'inherit',
+  cwd: WORKSPACE
+});
+
+sessionManager.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "replit-tools",
-  "version": "1.0.1",
-  "description": "Persist Claude Code sessions, auth, and history across Replit container restarts",
+  "version": "1.0.3",
+  "description": "DATA Tools - One command to set up Claude Code and Codex CLI on Replit with full persistence",
   "main": "index.js",
   "bin": {
     "replit-tools": "./index.js"