fix(multiplexer): fix daemon startup crash from invalid claude_status JSON (shepherdjerred#178)

shepherdjerred · claude · web-flow · commit 01957ab1dd28 · 2025-12-31T19:55:53.000-08:00
* fix(multiplexer): fix daemon startup crash from invalid claude_status JSON The daemon was crashing with "expected value at line 1 column 1" because the SQLite migration v3 set DEFAULT 'Unknown' for claude_status, but the code tried to parse it as JSON (which requires quoted "Unknown"). Changes: - Add FromStr impl for ClaudeWorkingStatus to parse raw enum variant names - Update session row parsing to try JSON first, then fall back to FromStr - Add detailed error messages showing which field failed and actual value - Add debug logging around database and session manager initialization - Improve client error handling for empty/malformed daemon responses - Add empty output check for gh pr checks in CI poller 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: decompiler --------- Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/packages/bun-decompile/.gitignore b/packages/bun-decompile/.gitignore
@@ -1,2 +1,3 @@
 out/
+out-*
 .bun-decompile-cache/
diff --git a/packages/bun-decompile/LICENSE b/packages/bun-decompile/LICENSE
diff --git a/packages/bun-decompile/README.md b/packages/bun-decompile/README.md
@@ -0,0 +1,213 @@
+# bun-decompile
+
+Extract and de-minify source code from Bun-compiled executables.
+
+Originally developed to inspect [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code), which ships as a Bun-compiled binary.
+
+## Features
+
+- **Binary Extraction**: Parse Bun's embedded module graph to extract all bundled sources
+- **Sourcemap Recovery**: Automatically recover original TypeScript/JSX sources from embedded sourcemaps
+- **AI De-minification**: Use OpenAI or Anthropic to rename minified identifiers back to meaningful names
+- **Functional Equivalence**: Babel-based renaming guarantees the de-minified code works identically
+
+## Installation
+
+```bash
+# Install locally
+bun add @shepherdjerred/bun-decompile
+
+# Or install globally
+bun add -g @shepherdjerred/bun-decompile
+```
+
+Requires [Bun](https://bun.sh) runtime.
+
+## Quick Start
+
+```bash
+# Extract sources from a compiled binary
+bun-decompile ./my-app -o ./extracted
+
+# De-minify with OpenAI (default)
+export OPENAI_API_KEY=sk-...
+bun-decompile ./my-app --deminify
+
+# De-minify with Anthropic Claude
+export ANTHROPIC_API_KEY=sk-ant-...
+bun-decompile ./my-app --deminify --provider anthropic
+
+# Batch mode (Anthropic only, 50% cheaper)
+bun-decompile ./my-app --deminify --provider anthropic --batch
+
+# De-minify a standalone JS file
+bun-decompile -f ./minified.js --deminify --yes
+```
+
+## How It Works
+
+### Binary Parsing
+
+Bun embeds a module graph at the end of compiled executables. The parser:
+
+1. Searches backwards from file end for the Bun trailer signature (`packages by bun`)
+2. Reads the offsets structure (32 bytes before trailer) containing:
+   - Total embedded data size
+   - Pointer to module array
+   - Entry point index
+   - Compile-time arguments
+3. Iterates the module entries (40 bytes each) extracting:
+   - Module path and contents
+   - Sourcemap and bytecode (if present)
+   - Loader type (js/ts/jsx/tsx/css/json/etc)
+   - Module format (ESM/CJS)
+
+### Sourcemap Recovery
+
+When sourcemaps are embedded (compiled with `--sourcemap`), the tool extracts original source files including:
+- TypeScript with full type annotations
+- JSX/TSX templates
+- Original comments and formatting
+
+### AI De-minification Pipeline
+
+The de-minification process uses a novel approach that guarantees functional equivalence:
+
+1. **Call Graph Analysis**: Build a dependency graph of all functions in the source
+2. **Bottom-Up Processing**: Process leaf functions first, so parent functions see renamed callees
+3. **LLM Rename Suggestions**: The LLM analyzes function behavior and outputs JSON rename mappings:
+   ```json
+   {
+     "processItems_40_120": {
+       "functionName": "filterValidItems",
+       "description": "Filters array to valid items",
+       "renames": { "t": "items", "r": "predicate", "n": "result" }
+     }
+   }
+   ```
+4. **Babel Transformation**: Babel's `scope.rename()` applies mappings, handling all scope complexity
+
+This approach (inspired by [humanify](https://github.com/jehna/humanify)) means the LLM never outputs code directly—only suggestions—eliminating LLM-introduced bugs.
+
+## CLI Reference
+
+```
+bun-decompile <binary> [options]
+bun-decompile --file <js-file> --deminify [options]
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-o, --output <dir>` | Output directory (default: `./decompiled`) |
+| `-f, --file <path>` | De-minify a JS file directly (skip binary extraction) |
+| `-v, --verbose` | Show detailed information |
+| `-q, --quiet` | Suppress progress display |
+| `-h, --help` | Show help message |
+
+### De-minification Options
+
+| Option | Description |
+|--------|-------------|
+| `--deminify` | Enable AI de-minification |
+| `--provider <name>` | LLM provider: `openai` or `anthropic` (default: openai) |
+| `--api-key <key>` | API key (or set `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`) |
+| `--model <model>` | Model to use (default: gpt-5-nano) |
+| `--batch` | Use Anthropic batch API (50% cheaper, async) |
+| `--resume <batch-id>` | Resume a pending batch job |
+| `--no-cache` | Disable result caching |
+| `--concurrency <n>` | Parallel API requests (default: 3, max: 20) |
+| `--yes` | Skip cost confirmation prompt |
+
+
+## Programmatic API
+
+### Extraction
+
+```typescript
+import {
+  decompileFile,
+  extractToDirectory,
+  getExtractionSummary,
+} from "@shepherdjerred/bun-decompile";
+
+// Parse binary and extract module graph
+const result = await decompileFile("./my-app");
+
+console.log(getExtractionSummary(result));
+// Bun Version: 1.2.0
+// Bundled Modules: 42
+// Entry Point: /src/index.ts
+// Original Sources: 38 (recovered from sourcemap)
+
+// Write to disk
+await extractToDirectory(result, "./extracted");
+```
+
+### De-minification
+
+```typescript
+import {
+  createConfig,
+  Deminifier,
+} from "@shepherdjerred/bun-decompile";
+
+const config = createConfig(process.env.OPENAI_API_KEY!, "./output", {
+  provider: "openai",
+  model: "gpt-5-nano",
+  verbose: true,
+});
+
+const deminifier = new Deminifier(config);
+
+// Estimate cost before processing
+const estimate = deminifier.estimateCost(minifiedSource);
+console.log(`Estimated cost: $${estimate.estimatedCost.toFixed(4)}`);
+
+// De-minify with progress tracking
+const result = await deminifier.deminifyFile(minifiedSource, {
+  fileName: "bundle.js",
+  onExtendedProgress: (progress) => {
+    console.log(`${progress.phase}: ${progress.current}/${progress.total}`);
+  },
+});
+
+console.log(deminifier.getStats());
+```
+
+### Key Exports
+
+- **Extraction**: `decompileFile`, `decompile`, `extractToDirectory`, `parseSourceMap`
+- **De-minification**: `Deminifier`, `createConfig`, `ClaudeClient`, `OpenAIClient`
+- **Types**: `DecompileResult`, `ModuleEntry`, `DeminifyConfig`, `CostEstimate`
+
+## Output Structure
+
+```
+output/
+├── metadata.json        # Bun version, entry point, module counts
+├── bundled/             # Transpiled/bundled JS sources + sourcemaps
+├── original/            # Original TS/TSX sources (from sourcemaps)
+├── deminified/          # AI de-minified output
+├── bytecode/            # Pre-compiled bytecode (if present)
+└── cache/               # LLM response cache
+```
+
+## Development
+
+```bash
+bun test          # Run tests
+bun run typecheck # Type check
+```
+
+### Project Structure
+
+- `src/index.ts` - CLI entry point
+- `src/lib/parser.ts` - Binary parsing
+- `src/lib/extractor.ts` - File extraction
+- `src/lib/deminify/` - AI de-minification (deminifier, babel-renamer, call-graph, LLM clients)
+
+## License
+
+GPL-3.0
diff --git a/packages/bun-decompile/src/lib/deminify/deminifier.ts b/packages/bun-decompile/src/lib/deminify/deminifier.ts
@@ -423,13 +423,7 @@ export class Deminifier {
 
     const result = await processor.processAll(source, graph, {
       // maxBatchTokens computed from model context limit if not specified
-<<<<<<< Updated upstream
       ...(options?.maxBatchTokens !== undefined ? { maxBatchTokens: options.maxBatchTokens } : {}),
-||||||| Stash base
-      maxBatchTokens: options?.maxBatchTokens,
-=======
-      ...(options?.maxBatchTokens !== undefined && { maxBatchTokens: options.maxBatchTokens }),
->>>>>>> Stashed changes
       verbose: this.config.verbose,
       onProgress: (progress) => {
         const progressUpdate: DeminifyProgress = {
diff --git a/packages/bun-decompile/src/lib/deminify/openai-batch.ts b/packages/bun-decompile/src/lib/deminify/openai-batch.ts
@@ -59,7 +59,7 @@ interface BatchRequest {
   body: {
     model: string;
     messages: Array<{ role: "system" | "user"; content: string }>;
-    max_tokens?: number;
+    max_completion_tokens?: number;
   };
 }
 
@@ -132,7 +132,7 @@ export class OpenAIBatchClient {
             { role: "system", content: systemPrompt },
             { role: "user", content: userPrompt },
           ],
-          max_tokens: this.config.maxTokens,
+          max_completion_tokens: this.config.maxTokens,
         },
       });
     }
diff --git a/packages/multiplexer/src/api/client.rs b/packages/multiplexer/src/api/client.rs
@@ -61,9 +61,25 @@ impl Client {
 
         let mut reader = BufReader::new(reader);
         let mut line = String::new();
-        reader.read_line(&mut line).await?;
+        let bytes_read = reader.read_line(&mut line).await?;
 
-        let response: Response = serde_json::from_str(line.trim())?;
+        if bytes_read == 0 {
+            anyhow::bail!("Daemon closed connection unexpectedly (0 bytes read)");
+        }
+
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            anyhow::bail!("Daemon returned empty response (read {} bytes, trimmed to empty)", bytes_read);
+        }
+
+        let response: Response = serde_json::from_str(trimmed).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to parse daemon response: {}. Raw response ({} bytes): {:?}",
+                e,
+                trimmed.len(),
+                if trimmed.len() > 200 { &trimmed[..200] } else { trimmed }
+            )
+        })?;
         Ok(response)
     }
 
diff --git a/packages/multiplexer/src/api/server.rs b/packages/multiplexer/src/api/server.rs
@@ -29,8 +29,13 @@ pub async fn run_daemon() -> anyhow::Result<()> {
 /// bound, or other I/O errors occur.
 pub async fn run_daemon_with_options(enable_proxy: bool) -> anyhow::Result<()> {
     // Initialize the store
+    tracing::debug!("Initializing database store...");
     let db_path = paths::database_path();
-    let store = Arc::new(SqliteStore::new(&db_path).await?);
+    let store = Arc::new(SqliteStore::new(&db_path).await.map_err(|e| {
+        tracing::error!("Failed to initialize database at {:?}: {}", db_path, e);
+        e
+    })?);
+    tracing::debug!("Database store initialized successfully");
 
     // Initialize proxy services if enabled
     let proxy_manager: Option<Arc<ProxyManager>> = if enable_proxy {
@@ -56,21 +61,31 @@ pub async fn run_daemon_with_options(enable_proxy: bool) -> anyhow::Result<()> {
     };
 
     // Initialize the session manager with proxy support if available
+    tracing::debug!("Initializing session manager...");
     let manager = if let Some(ref pm) = proxy_manager {
         let docker_proxy_config = DockerProxyConfig::new(
             pm.http_proxy_port(),
             pm.mux_dir().clone(),
         );
         let docker_backend = DockerBackend::with_proxy(docker_proxy_config);
-        let mut session_manager = SessionManager::with_docker_backend(store, docker_backend).await?;
+        let mut session_manager = SessionManager::with_docker_backend(store, docker_backend)
+            .await
+            .map_err(|e| {
+                tracing::error!("Failed to initialize session manager: {}", e);
+                e
+            })?;
 
         // Wire up proxy manager for per-session filtering
         session_manager.set_proxy_manager(Arc::clone(pm));
 
         Arc::new(session_manager)
     } else {
-        Arc::new(SessionManager::with_defaults(store).await?)
+        Arc::new(SessionManager::with_defaults(store).await.map_err(|e| {
+            tracing::error!("Failed to initialize session manager (no proxy): {}", e);
+            e
+        })?)
     };
+    tracing::info!("Session manager initialized");
 
     // Create the socket path
     let socket_path = paths::socket_path();
diff --git a/packages/multiplexer/src/ci/poller.rs b/packages/multiplexer/src/ci/poller.rs
@@ -87,7 +87,17 @@ impl CIPoller {
         }
 
         let json_output = String::from_utf8_lossy(&output.stdout);
-        let checks: Vec<serde_json::Value> = serde_json::from_str(&json_output)?;
+        if json_output.trim().is_empty() {
+            tracing::debug!(pr_url = %pr_url, "gh pr checks returned empty output");
+            return Ok(());
+        }
+        let checks: Vec<serde_json::Value> = serde_json::from_str(&json_output).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to parse gh pr checks output: {}. Raw output: {:?}",
+                e,
+                if json_output.len() > 200 { &json_output[..200] } else { &json_output }
+            )
+        })?;
 
         // Determine overall status
         let new_status = if checks.is_empty() {
diff --git a/packages/multiplexer/src/core/session.rs b/packages/multiplexer/src/core/session.rs
@@ -227,9 +227,10 @@ pub enum CheckStatus {
 
 /// Claude agent working status
 #[typeshare]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub enum ClaudeWorkingStatus {
     /// Unknown state (no hooks configured or no data yet)
+    #[default]
     Unknown,
 
     /// Claude is actively working (PreToolUse hook triggered)
@@ -245,6 +246,21 @@ pub enum ClaudeWorkingStatus {
     Idle,
 }
 
+impl std::str::FromStr for ClaudeWorkingStatus {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Unknown" => Ok(Self::Unknown),
+            "Working" => Ok(Self::Working),
+            "WaitingApproval" => Ok(Self::WaitingApproval),
+            "WaitingInput" => Ok(Self::WaitingInput),
+            "Idle" => Ok(Self::Idle),
+            _ => anyhow::bail!("unknown ClaudeWorkingStatus: {}", s),
+        }
+    }
+}
+
 /// Access mode for proxy filtering
 #[typeshare]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/packages/multiplexer/src/store/sqlite.rs b/packages/multiplexer/src/store/sqlite.rs

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`out/`
	`2`	`+out-*`
`2`	`3`	`.bun-decompile-cache/`