squeezr-ai 1.10.6 → 1.11.1

package/README.md

@@ -456,11 +456,28 @@ More importantly: sending 60-80% fewer tokens means Claude processes a smaller c
 
 The installer configures Squeezr to start automatically on login:
 
-| OS | Method |
-|---|---|
-| macOS | launchd (`~/Library/LaunchAgents/com.squeezr.plist`) |
-| Linux | systemd user service (`~/.config/systemd/user/squeezr.service`) |
-| Windows | Task Scheduler (runs at login, restarts on failure) |
+| OS | Method | Fallback |
+|---|---|---|
+| macOS | launchd (`~/Library/LaunchAgents/com.squeezr.plist`) | Shell auto-heal |
+| Linux | systemd user service (`~/.config/systemd/user/squeezr.service`) | Shell auto-heal |
+| Windows | Task Scheduler (runs at login, restarts on failure) | — |
+| **WSL2** | systemd → Task Scheduler (cascade) | Shell auto-heal |
+
+### WSL2 support
+
+`squeezr setup` detects WSL2 automatically and configures both sides:
+
+- **WSL shell**: env vars + auto-heal guard in `.bashrc` / `.zshrc`
+- **Windows**: env vars via `setx` (persistent in registry)
+- **Auto-start**: tries systemd first (WSL2 with `systemd=true` in `/etc/wsl.conf`), falls back to Windows Task Scheduler via `powershell.exe`
+
+### Auto-heal
+
+On every platform, `squeezr setup` adds a lightweight guard to your shell profile. Each time you open a terminal, it checks if the proxy is alive (`curl localhost:8080/squeezr/health`). If not, it starts it in the background — silently, in ~100ms. This means:
+
+- If the service manager fails, the proxy still starts on your next terminal
+- If the proxy crashes mid-session, the next terminal restores it
+- Zero manual intervention after `squeezr setup`, ever
 
 ---
 

package/bin/squeezr.js

@@ -47,6 +47,46 @@ function runNode(script, extraArgs = []) {
   child.on('exit', code => process.exit(code ?? 0))
 }
 
+async function startDaemon() {
+  const distIndex = path.join(ROOT, 'dist', 'index.js')
+  if (!fs.existsSync(distIndex)) {
+    console.error(`Error: ${distIndex} not found. Run 'npm run build' first.`)
+    process.exit(1)
+  }
+
+  // Check if already running
+  const port = process.env.SQUEEZR_PORT || 8080
+  const running = await new Promise(resolve => {
+    const req = http.get(`http://localhost:${port}/squeezr/health`, res => {
+      resolve(res.statusCode === 200)
+      res.destroy()
+    })
+    req.on('error', () => resolve(false))
+    req.setTimeout(2000, () => { req.destroy(); resolve(false) })
+  })
+  if (running) {
+    console.log(`Squeezr is already running on port ${port}`)
+    return
+  }
+
+  // Launch detached background process
+  const logDir = path.join(os.homedir(), '.squeezr')
+  const logFile = path.join(logDir, 'squeezr.log')
+  fs.mkdirSync(logDir, { recursive: true })
+  const logFd = fs.openSync(logFile, 'a')
+  const child = spawn(process.execPath, [distIndex], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    windowsHide: true,
+    cwd: ROOT,
+    env: { ...process.env, SQUEEZR_DAEMON: '1' },
+  })
+  child.unref()
+  fs.closeSync(logFd)
+  console.log(`Squeezr started in background (pid ${child.pid})`)
+  console.log(`Logs → ${logFile}`)
+}
+
 function showLogs() {
   const logFile = path.join(os.homedir(), '.squeezr', 'squeezr.log')
   if (!fs.existsSync(logFile)) {
@@ -211,12 +251,20 @@ function setupUnix() {
 
   console.log(`Setting up Squeezr for ${platform === 'darwin' ? 'macOS' : 'Linux'}...\n`)
 
-  // 1. Set env vars in shell profile
-  const exportLines = [
-    'export ANTHROPIC_BASE_URL=http://localhost:8080',
-    'export OPENAI_BASE_URL=http://localhost:8080',
-    'export GEMINI_API_BASE_URL=http://localhost:8080',
-  ]
+  // 1. Set env vars + auto-heal guard in shell profile
+  const distIndex = path.join(ROOT, 'dist', 'index.js')
+  const port = process.env.SQUEEZR_PORT || 8080
+  const shellBlock = [
+    `# squeezr env vars`,
+    `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
+    `export OPENAI_BASE_URL=http://localhost:${port}`,
+    `export GEMINI_API_BASE_URL=http://localhost:${port}`,
+    `# squeezr auto-heal: start proxy if not running`,
+    `if ! curl -sf http://localhost:${port}/squeezr/health >/dev/null 2>&1; then`,
+    `  nohup ${nodeExe} ${distIndex} >> "${os.homedir()}/.squeezr/squeezr.log" 2>&1 &`,
+    `  disown`,
+    `fi`,
+  ].join('\n')
   const marker = '# squeezr env vars'
   const profiles = [
     path.join(os.homedir(), '.zshrc'),
@@ -226,10 +274,19 @@ function setupUnix() {
   const profile = profiles.find(p => fs.existsSync(p)) ?? profiles[0]
   const existing = fs.existsSync(profile) ? fs.readFileSync(profile, 'utf-8') : ''
   if (!existing.includes(marker)) {
-    fs.appendFileSync(profile, `\n${marker}\n${exportLines.join('\n')}\n`)
-    console.log(`  [ok] Env vars added to ${profile}`)
+    fs.appendFileSync(profile, `\n${shellBlock}\n`)
+    console.log(`  [ok] Env vars + auto-heal added to ${profile}`)
   } else {
-    console.log(`  [skip] Env vars already in ${profile}`)
+    if (!existing.includes('squeezr auto-heal')) {
+      const updatedContent = existing.replace(
+        /# squeezr env vars\n(?:export [A-Z_]+=http:\/\/localhost:\d+\n?)*/,
+        shellBlock + '\n'
+      )
+      fs.writeFileSync(profile, updatedContent)
+      console.log(`  [ok] Auto-heal guard added to ${profile}`)
+    } else {
+      console.log(`  [skip] Env vars + auto-heal already in ${profile}`)
+    }
   }
 
   // 2a. macOS — launchd
@@ -300,16 +357,184 @@ Done!
 `)
 }
 
+// ── WSL2 detection ───────────────────────────────────────────────────────────
+
+function isWSL() {
+  try {
+    const release = fs.readFileSync('/proc/version', 'utf-8')
+    return /microsoft|wsl/i.test(release)
+  } catch {
+    return false
+  }
+}
+
+// ── squeezr setup — WSL2 ────────────────────────────────────────────────────
+
+function setupWSL() {
+  const nodeExe = process.execPath
+  const distIndex = path.join(ROOT, 'dist', 'index.js')
+
+  console.log('Setting up Squeezr for WSL2...\n')
+
+  // 1. Set env vars + auto-heal guard in WSL shell profile (.bashrc / .zshrc)
+  //    The guard checks if the proxy is alive on terminal open. If not, it starts
+  //    it in the background. This is the safety net for WSL2 where systemd and
+  //    Task Scheduler may both fail.
+  const port = process.env.SQUEEZR_PORT || 8080
+  const shellBlock = [
+    `# squeezr env vars`,
+    `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
+    `export OPENAI_BASE_URL=http://localhost:${port}`,
+    `export GEMINI_API_BASE_URL=http://localhost:${port}`,
+    `# squeezr auto-heal: start proxy if not running`,
+    `if ! curl -sf http://localhost:${port}/squeezr/health >/dev/null 2>&1; then`,
+    `  nohup ${nodeExe} ${distIndex} >> "${os.homedir()}/.squeezr/squeezr.log" 2>&1 &`,
+    `  disown`,
+    `fi`,
+  ].join('\n')
+  const marker = '# squeezr env vars'
+  const profiles = [
+    path.join(os.homedir(), '.zshrc'),
+    path.join(os.homedir(), '.bashrc'),
+    path.join(os.homedir(), '.bash_profile'),
+  ]
+  const profile = profiles.find(p => fs.existsSync(p)) ?? profiles[1]
+  const existing = fs.existsSync(profile) ? fs.readFileSync(profile, 'utf-8') : ''
+  if (!existing.includes(marker)) {
+    fs.appendFileSync(profile, `\n${shellBlock}\n`)
+    console.log(`  [ok] Env vars + auto-heal added to ${profile}`)
+  } else {
+    // Update existing block to include auto-heal if missing
+    if (!existing.includes('squeezr auto-heal')) {
+      const updatedContent = existing.replace(
+        /# squeezr env vars\n(?:export [A-Z_]+=http:\/\/localhost:\d+\n?)*/,
+        shellBlock + '\n'
+      )
+      fs.writeFileSync(profile, updatedContent)
+      console.log(`  [ok] Auto-heal guard added to ${profile}`)
+    } else {
+      console.log(`  [skip] Env vars + auto-heal already in ${profile}`)
+    }
+  }
+
+  // 2. Set Windows env vars via setx.exe (so Windows-launched CLIs see them)
+  const setxExe = '/mnt/c/Windows/System32/setx.exe'
+  const winVars = {
+    ANTHROPIC_BASE_URL: 'http://localhost:8080',
+    OPENAI_BASE_URL: 'http://localhost:8080',
+    GEMINI_API_BASE_URL: 'http://localhost:8080',
+  }
+  if (fs.existsSync(setxExe)) {
+    for (const [key, value] of Object.entries(winVars)) {
+      try {
+        execSync(`"${setxExe}" ${key} "${value}"`, { stdio: 'pipe' })
+        console.log(`  [ok] Windows env: ${key}=${value}`)
+      } catch {
+        console.log(`  [skip] Windows env: ${key} could not be set`)
+      }
+    }
+  } else {
+    console.log('  [skip] setx.exe not found — Windows env vars not set')
+  }
+
+  // 3. Auto-start: try systemd first (WSL2 with systemd enabled), fallback to
+  //    Windows Task Scheduler, then plain background process
+  let autoStartDone = false
+
+  // 3a. Try systemd (works on newer WSL2 with [boot] systemd=true in wsl.conf)
+  try {
+    const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user')
+    fs.mkdirSync(serviceDir, { recursive: true })
+    const servicePath = path.join(serviceDir, 'squeezr.service')
+    fs.writeFileSync(servicePath, `[Unit]
+Description=Squeezr AI proxy
+After=network.target
+
+[Service]
+ExecStart=${nodeExe} ${distIndex}
+Restart=always
+RestartSec=5
+WorkingDirectory=${ROOT}
+
+[Install]
+WantedBy=default.target
+`)
+    execSync('systemctl --user daemon-reload && systemctl --user enable --now squeezr', { stdio: 'pipe' })
+    console.log('  [ok] Auto-start registered via systemd')
+    autoStartDone = true
+  } catch {
+    // systemd not available — try Windows Task Scheduler
+  }
+
+  // 3b. Fallback: Windows Task Scheduler via powershell.exe
+  if (!autoStartDone) {
+    const winNodeExe = execSync('wslpath -w "$(which node)"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+    const winDistIndex = execSync(`wslpath -w "${distIndex}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+    const winRoot = execSync(`wslpath -w "${ROOT}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+    const taskName = 'Squeezr'
+    const ps = [
+      `$e = Get-ScheduledTask -TaskName '${taskName}' -ErrorAction SilentlyContinue`,
+      `if ($e) { Unregister-ScheduledTask -TaskName '${taskName}' -Confirm:$false }`,
+      `$a = New-ScheduledTaskAction -Execute 'wsl.exe' -Argument '-d ${os.hostname()} -- ${nodeExe} ${distIndex}' -WorkingDirectory '${winRoot}'`,
+      `$t = New-ScheduledTaskTrigger -AtLogon`,
+      `$s = New-ScheduledTaskSettingsSet -ExecutionTimeLimit 0 -RestartCount 5 -RestartInterval (New-TimeSpan -Minutes 1)`,
+      `Register-ScheduledTask -TaskName '${taskName}' -Action $a -Trigger $t -Settings $s -Force | Out-Null`,
+    ].join('; ')
+
+    try {
+      execSync(`powershell.exe -NoProfile -Command "${ps}"`, { stdio: 'pipe' })
+      console.log('  [ok] Auto-start registered via Windows Task Scheduler')
+      autoStartDone = true
+    } catch {
+      console.log('  [warn] Task Scheduler failed — run PowerShell as admin for auto-start')
+    }
+  }
+
+  // 4. Start proxy now as a detached background process
+  const logDir = path.join(os.homedir(), '.squeezr')
+  const logFile = path.join(logDir, 'squeezr.log')
+  fs.mkdirSync(logDir, { recursive: true })
+  const logFd = fs.openSync(logFile, 'a')
+  const child = spawn(nodeExe, [distIndex], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    cwd: ROOT,
+  })
+  child.unref()
+  fs.closeSync(logFd)
+  console.log(`  [ok] Squeezr started in background (pid ${child.pid})`)
+  console.log(`  [ok] Logs → ${logFile}`)
+
+  // 5. Apply env vars to current process so calling `source` is not needed
+  //    This won't affect the parent shell, but at least prints guidance.
+  console.log(`
+Done!
+
+  Squeezr is running on http://localhost:8080
+  All CLIs (Claude Code, Codex, Aider, Gemini, Ollama) are configured.
+
+  Windows env vars are set (effective in new terminals immediately).
+  WSL env vars added to ${profile}.
+
+  To activate in THIS terminal: source ${profile}
+  New terminals will have everything configured automatically.
+
+  squeezr status   — check it's running
+  squeezr gain     — see token savings
+`)
+}
+
 // ── CLI router ────────────────────────────────────────────────────────────────
 
 switch (command) {
   case undefined:
   case 'start':
-    runNode('index.js')
+    startDaemon()
     break
 
   case 'setup':
     if (process.platform === 'win32') setupWindows()
+    else if (isWSL()) setupWSL()
     else setupUnix()
     break
 

package/dist/index.js

@@ -11,9 +11,19 @@ serve({ fetch: app.fetch, port: PORT }, () => {
     console.log(`Backends: Anthropic → Haiku | OpenAI → GPT-4o-mini | Gemini → Flash-8B | Local → ${config.localCompressionModel}`);
     console.log(`Stats: http://localhost:${PORT}/squeezr/stats`);
 });
-process.on('SIGINT', () => {
-    const s = stats.summary();
-    console.log(`\n[squeezr] Session summary: ${s.requests} requests | -${s.total_saved_chars.toLocaleString()} chars (~${s.total_saved_tokens.toLocaleString()} tokens, ${s.savings_pct}% saved)`);
-    process.exit(0);
-});
+const isDaemon = !!process.env.SQUEEZR_DAEMON;
+if (isDaemon) {
+    // Daemon mode: ignore SIGINT (Ctrl+C) and SIGHUP (terminal close)
+    // Only stop via `squeezr stop` which sends SIGTERM
+    process.on('SIGINT', () => { });
+    process.on('SIGHUP', () => { });
+}
+else {
+    // Dev mode (npm run dev): allow Ctrl+C to stop
+    process.on('SIGINT', () => {
+        const s = stats.summary();
+        console.log(`\n[squeezr] Session summary: ${s.requests} requests | -${s.total_saved_chars.toLocaleString()} chars (~${s.total_saved_tokens.toLocaleString()} tokens, ${s.savings_pct}% saved)`);
+        process.exit(0);
+    });
+}
 process.on('SIGTERM', () => process.exit(0));

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.10.6";
+export declare const VERSION = "1.11.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.10.6';
+export const VERSION = '1.11.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squeezr-ai",
-  "version": "1.10.6",
+  "version": "1.11.1",
   "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
   "keywords": [
     "claude",