replit-tools 1.2.40 → 1.2.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replit-tools",
-  "version": "1.2.40",
+  "version": "1.2.42",
   "description": "DATA Tools - One command to set up Claude Code and Codex CLI on Replit with full persistence",
   "main": "index.js",
   "bin": {

package/scripts/claude-session-manager.sh

@@ -301,16 +301,25 @@ get_terminal_last_session() {
     fi
 }
 
-# Recent sessions within last 24h (max 9). Prints "NUM|TOOL|ID|SNIPPET" per line.
+# Recent sessions within configured window (max 9). Prints "NUM|TOOL|ID|AGO|SNIPPET" per line.
+# Window read from ${REPLIT_TOOLS}/config.json: recentWindowHours (default 48)
 get_recent_24h_sessions() {
     local history="${HOME}/.claude/history.jsonl"
     local projects_dir="${HOME}/.claude/projects/-home-runner-workspace"
     local codex_sessions_dir="${HOME}/.codex/sessions"
+    local config_path="${REPLIT_TOOLS}/config.json"
 
     node -e "
         const fs = require('fs');
         const path = require('path');
-        const cutoff = Date.now() - 24*60*60*1000;
+        let hours = 48;
+        try {
+            if (fs.existsSync('${config_path}')) {
+                const cfg = JSON.parse(fs.readFileSync('${config_path}', 'utf8'));
+                if (typeof cfg.recentWindowHours === 'number' && cfg.recentWindowHours > 0) hours = cfg.recentWindowHours;
+            }
+        } catch(e) {}
+        const cutoff = Date.now() - hours*60*60*1000;
         const cwd = '/home/runner/workspace';
         const sessions = new Map();
 
@@ -563,8 +572,25 @@ claude_prompt() {
         local recent_tools=()
         local recent_ids=()
         if [ -n "$recent_24h" ]; then
+            # Read configured window for label
+            local window_hours=48
+            if [ -f "${REPLIT_TOOLS}/config.json" ] && command -v node &>/dev/null; then
+                window_hours=$(node -e "try{const c=require('${REPLIT_TOOLS}/config.json');console.log(c.recentWindowHours||48)}catch(e){console.log(48)}" 2>/dev/null)
+            fi
+            local window_label
+            if [ "$window_hours" -ge 8760 ]; then
+                window_label="$((window_hours / 8760))y"
+            elif [ "$window_hours" -ge 720 ]; then
+                window_label="$((window_hours / 720))mo"
+            elif [ "$window_hours" -ge 168 ]; then
+                window_label="$((window_hours / 168))w"
+            elif [ "$window_hours" -ge 24 ]; then
+                window_label="$((window_hours / 24))d"
+            else
+                window_label="${window_hours}h"
+            fi
             echo ""
-            echo -e "  \033[1mRecent (last 24h):\033[0m"
+            echo -e "  \033[1mRecent (last $window_label):\033[0m"
             while IFS='|' read -r num tool id when snippet; do
                 [ -z "$num" ] && continue
                 recent_tools[$num]="$tool"

package/scripts/setup-claude-code.sh

@@ -39,7 +39,7 @@ LOCAL_SHARE_CLAUDE="${HOME}/.local/share/claude"
 
 # Version file
 VERSION_FILE="${REPLIT_TOOLS}/.version"
-PACKAGE_NAME="replit-tools"
+PACKAGE_NAME="data-remote"
 
 # Logging helper
 log() {
@@ -171,54 +171,130 @@ for f in "${SSH_PERSISTENT}"/*; do
 done
 
 # =============================================================================
-# Step 2.6: Force forever-persistence settings for Claude + Codex
+# Step 2.6: Apply user-config persistence + sync append-only mirror archive
 # =============================================================================
-# Claude: cleanupPeriodDays = 365250 (~1000 years) so sessions never auto-delete
-# Codex: history.max_bytes = 1 TiB so history.jsonl never rotates
-#        (session rollouts under ~/.codex/sessions/ are already kept forever)
+# Config at ${REPLIT_TOOLS}/config.json:
+#   {
+#     "recentWindowHours": 48,        // recent sessions list window
+#     "persistenceDays": 365250,      // Claude cleanupPeriodDays + Codex history bytes
+#     "mirror": { "enabled": true }   // append-only backup mirror of sessions
+#   }
+# The mirror is at ${REPLIT_TOOLS}/.session-archive/ — append-only: files only grow,
+# never shrink. If Claude/Codex deletes a session, the mirror still has it.
 if command -v node &>/dev/null; then
-    PERSIST_OUTPUT=$(CLAUDE_PERSISTENT_DIR="${CLAUDE_PERSISTENT}" CODEX_PERSISTENT_DIR="${CODEX_PERSISTENT}" node -e '
+    PERSIST_OUTPUT=$(REPLIT_TOOLS_DIR="${REPLIT_TOOLS}" CLAUDE_PERSISTENT_DIR="${CLAUDE_PERSISTENT}" CODEX_PERSISTENT_DIR="${CODEX_PERSISTENT}" node -e '
         const fs = require("fs");
+        const path = require("path");
+
+        // Load config with defaults
+        const configPath = process.env.REPLIT_TOOLS_DIR + "/config.json";
+        const defaults = { recentWindowHours: 48, persistenceDays: 365250, mirror: { enabled: true } };
+        let config = defaults;
+        try {
+            if (fs.existsSync(configPath)) {
+                const loaded = JSON.parse(fs.readFileSync(configPath, "utf8"));
+                config = { ...defaults, ...loaded, mirror: { ...defaults.mirror, ...(loaded.mirror || {}) } };
+            } else {
+                fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2) + "\n");
+                console.log("Created config at " + configPath);
+            }
+        } catch(e) { config = defaults; }
+
+        const persistDays = Math.max(1, parseInt(config.persistenceDays, 10) || 365250);
+        // Claude needs days; Codex max_bytes scales with days (rough: 1 MiB per day, min 100 MiB)
+        const codexMaxBytes = Math.max(104857600, persistDays * 1048576);
+
+        // --- Claude settings.json ---
         const claudeSettingsPath = process.env.CLAUDE_PERSISTENT_DIR + "/settings.json";
         try {
             let s = {};
             if (fs.existsSync(claudeSettingsPath)) {
                 try { s = JSON.parse(fs.readFileSync(claudeSettingsPath, "utf8")); } catch(e) { s = {}; }
             }
-            if (s.cleanupPeriodDays !== 365250) {
-                s.cleanupPeriodDays = 365250;
+            if (s.cleanupPeriodDays !== persistDays) {
+                s.cleanupPeriodDays = persistDays;
                 fs.writeFileSync(claudeSettingsPath, JSON.stringify(s, null, 2) + "\n");
-                console.log("Claude cleanupPeriodDays set to 365250 (~1000 years)");
+                console.log("Claude cleanupPeriodDays = " + persistDays);
             }
         } catch(e) { console.error("Could not update Claude settings: " + e.message); }
 
+        // --- Codex config.toml ---
         const codexConfigPath = process.env.CODEX_PERSISTENT_DIR + "/config.toml";
         try {
             let c = "";
             if (fs.existsSync(codexConfigPath)) c = fs.readFileSync(codexConfigPath, "utf8");
-            const desired = "1099511627776"; // 1 TiB
-            const hasHistory = /\[history\]/.test(c);
+            const desired = String(codexMaxBytes);
             let updated = false;
-            if (!hasHistory) {
-                c = (c.trimEnd() + "\n\n[history]\nmax_bytes = " + desired + "\n").trimStart();
+            // Codex requires persistence field when [history] section is present
+            if (!/\[history\]/.test(c)) {
+                c = (c.trimEnd() + "\n\n[history]\npersistence = \"save-all\"\nmax_bytes = " + desired + "\n").trimStart();
                 updated = true;
             } else {
-                const m = c.match(/(\[history\][\s\S]*?)max_bytes\s*=\s*(\d+)/);
-                if (m) {
-                    if (m[2] !== desired) {
+                // Ensure persistence field exists
+                if (!/(\[history\][\s\S]*?)persistence\s*=/.test(c)) {
+                    c = c.replace(/\[history\](\s*)/, "[history]$1persistence = \"save-all\"\n");
+                    updated = true;
+                }
+                // Ensure max_bytes is set correctly
+                if (/max_bytes\s*=\s*(\d+)/.test(c)) {
+                    const cur = c.match(/max_bytes\s*=\s*(\d+)/)[1];
+                    if (cur !== desired) {
                         c = c.replace(/(\[history\][\s\S]*?max_bytes\s*=\s*)\d+/, "$1" + desired);
                         updated = true;
                     }
                 } else {
-                    c = c.replace(/\[history\](\s*)/, "[history]$1max_bytes = " + desired + "\n");
+                    c = c.replace(/(\[history\][\s\S]*?persistence\s*=\s*"[^"]*"\s*\n)/, "$1max_bytes = " + desired + "\n");
                     updated = true;
                 }
             }
             if (updated) {
                 fs.writeFileSync(codexConfigPath, c);
-                console.log("Codex history.max_bytes set to 1 TiB");
+                console.log("Codex history.max_bytes = " + desired);
             }
         } catch(e) { console.error("Could not update Codex config: " + e.message); }
+
+        // --- Append-only mirror sync ---
+        if (config.mirror && config.mirror.enabled) {
+            const mirrorBase = process.env.REPLIT_TOOLS_DIR + "/.session-archive";
+            const syncTree = (srcDir, mirrorDir) => {
+                if (!fs.existsSync(srcDir)) return { copied: 0, grew: 0 };
+                let copied = 0, grew = 0;
+                const walk = (rel) => {
+                    const srcPath = rel ? path.join(srcDir, rel) : srcDir;
+                    const mirrorPath = rel ? path.join(mirrorDir, rel) : mirrorDir;
+                    let stat;
+                    try { stat = fs.statSync(srcPath); } catch(e) { return; }
+                    if (stat.isDirectory()) {
+                        try { fs.mkdirSync(mirrorPath, { recursive: true }); } catch(e){}
+                        let entries = [];
+                        try { entries = fs.readdirSync(srcPath); } catch(e) { return; }
+                        for (const e of entries) walk(rel ? path.join(rel, e) : e);
+                    } else if (stat.isFile()) {
+                        let mirrorSize = 0;
+                        if (fs.existsSync(mirrorPath)) mirrorSize = fs.statSync(mirrorPath).size;
+                        if (stat.size > mirrorSize) {
+                            try {
+                                fs.mkdirSync(path.dirname(mirrorPath), { recursive: true });
+                                fs.copyFileSync(srcPath, mirrorPath);
+                                if (mirrorSize === 0) copied++; else grew++;
+                            } catch(e){}
+                        }
+                    }
+                };
+                walk("");
+                return { copied, grew };
+            };
+            try {
+                fs.mkdirSync(mirrorBase, { recursive: true });
+                const c1 = syncTree(process.env.CLAUDE_PERSISTENT_DIR + "/projects", mirrorBase + "/claude/projects");
+                const c2 = syncTree(process.env.CLAUDE_PERSISTENT_DIR + "/history.jsonl", mirrorBase + "/claude/history.jsonl");
+                const c3 = syncTree(process.env.CODEX_PERSISTENT_DIR + "/sessions", mirrorBase + "/codex/sessions");
+                const c4 = syncTree(process.env.CODEX_PERSISTENT_DIR + "/history.jsonl", mirrorBase + "/codex/history.jsonl");
+                const total = c1.copied + c2.copied + c3.copied + c4.copied;
+                const grew = c1.grew + c2.grew + c3.grew + c4.grew;
+                if (total > 0 || grew > 0) console.log("Archive mirror: +" + total + " new, " + grew + " updated");
+            } catch(e) { console.error("Mirror sync failed: " + e.message); }
+        }
     ' 2>&1)
     if [ -n "${PERSIST_OUTPUT}" ]; then
         while IFS= read -r line; do log "✅ ${line}"; done <<< "${PERSIST_OUTPUT}"