@mmmbuto/anthmorph 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 0.1.4
+
+- hardened AnthMorph for public GitHub and npm release flow
+- expanded public docs into linked guides for Claude Code setup, packaging, and release
+- added Docker-based verification scripts for secret scan, Linux build, Rust tests, and npm dry-runs
+- cleaned npm publish surface and clarified Termux prebuilt vs Linux source-build behavior
+- kept Claude Code CLI compatibility improvements, real-backend corpus tests, and bootstrap flow from the current working line
+
+## 0.1.3
+
+- added `compat` mode and separated compatibility posture from backend profile
+- added `/health`, `/v1/models`, and `/v1/messages/count_tokens`
+- improved Claude Code request compatibility and SSE behavior
+- added real-backend smoke coverage for Chutes, MiniMax, and Alibaba rejection flow
+
+## 0.1.2
+
+- fixed MCP `tool_use` streaming behavior for Claude Code compatibility
+
+## 0.1.1
+
+- added global CLI packaging
+- added bundled Termux prebuilt binary
+- improved npm install path for local usage
+
+## 0.1.0
+
+- initial public release
+- Anthropic `/v1/messages` ingress with OpenAI-compatible upstream translation
+- Chutes-first Rust proxy with streaming, tools, and local operator CLI

package/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "AnthMorph"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "async-stream",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "AnthMorph"
-version = "0.1.2"
+version = "0.1.4"
 edition = "2021"
 description = "Anthropic to OpenAI-compatible proxy"
 license = "MIT"

package/README.md

@@ -1,40 +1,32 @@
 # AnthMorph
 
-[![Status](https://img.shields.io/badge/Status-0.1.2-blue.svg)](#project-status)
+[![Status](https://img.shields.io/badge/Status-0.1.4-blue.svg)](#project-status)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Rust](https://img.shields.io/badge/Rust-1.94%2B-orange.svg)](https://www.rust-lang.org)
 [![Target](https://img.shields.io/badge/Target-Termux%20%2F%20Linux-green.svg)](https://termux.dev)
 [![npm](https://img.shields.io/npm/v/@mmmbuto/anthmorph?style=flat-square&logo=npm)](https://www.npmjs.com/package/@mmmbuto/anthmorph)
 
 AnthMorph is a Chutes-first Anthropic `/v1/messages` proxy written in Rust.
-It lets Claude-style clients talk to Chutes or other OpenAI-compatible backends through a safer, profile-aware translation layer.
-
-Core capabilities:
-- Anthropic `/v1/messages` ingress with OpenAI-compatible upstream translation
-- `chutes` profile optimized for Chutes-specific compatibility, including `top_k` and reasoning handling
-- `openai_generic` profile for conservative compatibility with generic OpenAI-style providers
-- Streaming SSE translation with fragmented tool-call handling
-- Local control CLI for init, start, stop, restart, status, and logs
-- Termux-first npm distribution with bundled prebuilt binary and local self-build on Linux/macOS
+It lets Claude-style clients talk to Chutes or other OpenAI-compatible backends through a profile-aware translation layer optimized for Claude Code CLI compatibility.
 
 ## Project Status
 
-- Current line: `0.1.2`
+- Current line: `0.1.4`
 - Primary target: `chutes.ai`
 - Secondary target: generic OpenAI-compatible endpoints
-- Tested locally against Chutes, MiniMax, and Alibaba Coding Plan rejection handling
-- Distribution paths: Termux-first npm package with bundled prebuilt binary, plus source builds
-- Repository metadata is aligned for GitHub and npm publication
+- Release model: MIT-licensed GitHub repo plus public npm package
+- Packaging model: one npm package with Termux prebuilt and Linux source-build path
 
-## Quickstart
+## Highlights
 
-1. Install
-
-Source build:
+- Anthropic `/v1/messages` ingress with OpenAI-compatible upstream translation
+- `chutes` and `openai_generic` backend profiles
+- `strict` and `compat` runtime modes
+- Claude Code bootstrap via `anthmorphctl bootstrap claude-code`
+- real-backend validation for Chutes, MiniMax, and Alibaba rejection flow
+- Docker release checks for secret scan, Rust tests, Linux build, and npm dry-runs
 
-```bash
-cargo build --release
-```
+## Install
 
 Global npm install:
 
@@ -42,145 +34,78 @@ Global npm install:
 npm install -g @mmmbuto/anthmorph
 ```
 
-2. Initialize Chutes profile
+Local source build:
 
 ```bash
-export CHUTES_API_KEY=your_key_here
-anthmorphctl init chutes --port 3107
-```
-
-3. Start proxy
-
-```bash
-anthmorphctl start
-anthmorphctl status
+cargo build --release
 ```
 
-4. Stop proxy
+Linux Docker build:
 
 ```bash
-anthmorphctl stop
+./scripts/docker_build_linux.sh
 ```
 
-## CLI Control
-
-`anthmorphctl` is the operator entrypoint.
-By default it stores runtime state under `.anthmorph/` inside the installed package root.
-For shell wrappers and daily usage, prefer setting `ANTHMORPH_STATE_DIR` to a dedicated writable path.
+## Quickstart
 
-Common commands:
+Initialize and run against Chutes:
 
 ```bash
-anthmorphctl init chutes
-anthmorphctl init minimax
-anthmorphctl init openai --backend-url https://api.example.com/v1 --model my-model --key-env EXAMPLE_API_KEY
+export CHUTES_API_KEY=your_key_here
+anthmorphctl init chutes --port 3107 --compat-mode compat
 anthmorphctl start
 anthmorphctl status
-anthmorphctl logs
-anthmorphctl stop
 ```
 
-Direct binary usage is also available:
+Point Claude Code at AnthMorph:
 
 ```bash
-anthmorph --port 3107 --backend-profile chutes --backend-url https://llm.chutes.ai/v1 --model Qwen/Qwen3-Coder-Next-TEE --api-key "$CHUTES_API_KEY"
+anthmorphctl bootstrap claude-code --write
 ```
 
-## Architecture
-
-- `Ingress`: accepts Anthropic `/v1/messages` requests and validates profile-safe behavior.
-- `Transform`: converts Anthropic messages, tools, and stop reasons into OpenAI-compatible payloads.
-- `Streaming`: translates upstream SSE chunks back into Anthropic-style streaming events.
-- `Profiles`: selects `chutes` or `openai_generic` behavior for request and response handling.
-- `Control CLI`: manages local config, runtime state, start/stop/status, and operator logs.
-
-## API Key Policy
-
-Preferred mode:
-- Store only the environment variable name with `anthmorphctl set key-env ENV_NAME`
-- Keep the secret in your shell environment
-
-Optional mode:
-- Persist the key locally with `anthmorphctl set key VALUE --save`
-
-Recommendation:
-- Do not save API keys in the repo by default
-- Use env vars for daily operation and CI
-
-## Backend Profiles
-
-- `chutes`: optimized path for Chutes, including `top_k` pass-through and reasoning support
-- `openai_generic`: strips nonstandard fields and fails conservatively when the backend cannot represent Anthropic semantics safely
-
-## Safety Rules
+Stop the proxy:
 
-- Assistant thinking blocks in request history are rejected instead of being downgraded to plain text
-- Generic mode rejects backend reasoning content that cannot be represented safely
-- Streaming tool-call deltas support contiguous fragments and fail closed on unsafe interleaving
-- Optional ingress auth supports `Authorization: Bearer ...` or `x-api-key`
-- CORS is disabled unless explicitly configured
+```bash
+anthmorphctl stop
+```
 
-## Real Backend Coverage
+## Docs
 
-Current integration coverage:
-- `chutes.ai`: positive end-to-end smoke test
-- `MiniMax`: positive end-to-end smoke test in generic mode
-- `Alibaba Coding Plan`: negative expected test documenting upstream rejection for generic chat-completions flow
+- Claude Code setup: [docs/CLAUDE_CODE_SETUP.md](/home/dag/Dev/AnthMorph/docs/CLAUDE_CODE_SETUP.md)
+- Packaging details: [docs/PACKAGING.md](/home/dag/Dev/AnthMorph/docs/PACKAGING.md)
+- Release guide: [docs/RELEASE.md](/home/dag/Dev/AnthMorph/docs/RELEASE.md)
+- Changelog: [CHANGELOG.md](/home/dag/Dev/AnthMorph/CHANGELOG.md)
 
-## npm Packaging
+## Packaging Notes
 
-This repository already includes npm packaging files:
-- `package.json`
-- `bin/anthmorph`
-- `scripts/postinstall.js`
+- Termux on Android/aarch64 uses the bundled prebuilt in `prebuilt/anthmorph`
+- Linux and macOS build from source during install
+- Docker is the supported reproducible release path on VPS3 and similar hosts
+- If Cargo is unavailable on Linux/macOS, use the Docker build path documented in `docs/PACKAGING.md`
 
-Packaging behavior:
-- `npm install -g @mmmbuto/anthmorph` exposes `anthmorph` and `anthmorphctl`
-- Termux uses the bundled `prebuilt/anthmorph` from the npm tarball
-- Linux and macOS use `postinstall` to build locally with Cargo
-- if no binary is available later, the `anthmorph` shim still falls back to a local release build
+## Validation
 
-## Build And Test
+Local Rust tests:
 
 ```bash
-cargo test
-npm pack --dry-run
+cargo test -- --nocapture
 ```
 
-Real backend smoke tests:
+Docker release checks:
 
 ```bash
-./scripts/smoke_test.sh chutes
-./scripts/smoke_test.sh minimax
-./scripts/smoke_test.sh alibaba
+./scripts/docker_release_checks.sh
 ```
 
-## Repository Layout
+Real payload replay:
 
-```text
-src/                  Rust proxy implementation
-bin/                  npm-exposed executable shims
-scripts/              control CLI, smoke tests, npm postinstall
-tests/                protocol and real-backend integration tests
+```bash
+./scripts/test_claude_code_patterns_real.sh chutes
+./scripts/test_claude_code_patterns_real.sh minimax
 ```
 
-## Documentation
-
-- Repository: https://github.com/DioNanos/AnthMorph
-- npm package: https://www.npmjs.com/package/@mmmbuto/anthmorph
-- Issue tracker: https://github.com/DioNanos/AnthMorph/issues
-
-## Roadmap
-
-1. Broader compatibility validation across more OpenAI-compatible providers
-2. End-to-end validation against real Claude-style clients
-3. Public-deployment hardening with rate limits and clearer auth policy
-4. Better streaming coverage for complex multi-tool interleaving
-
 ## License
 
 MIT License
-<p>
-Copyright (c) 2026 Davide A. Guglielmi<br>
-Made in Italy
-</p>
+
+Copyright (c) 2026 Davide A. Guglielmi

package/docs/CLAUDE_CODE_SETUP.md

@@ -0,0 +1,78 @@
+# Claude Code Setup
+
+This guide connects Claude Code to a local AnthMorph instance.
+
+## Quick path
+
+1. Install AnthMorph.
+
+```bash
+npm install -g @mmmbuto/anthmorph
+```
+
+2. Initialize a backend profile.
+
+```bash
+export CHUTES_API_KEY=your_key_here
+anthmorphctl init chutes --port 3107
+```
+
+3. Start the proxy.
+
+```bash
+anthmorphctl start
+anthmorphctl status
+```
+
+4. Generate Claude Code settings.
+
+Print the payload:
+
+```bash
+anthmorphctl bootstrap claude-code
+```
+
+Write `~/.claude/settings.json` directly:
+
+```bash
+anthmorphctl bootstrap claude-code --write
+```
+
+## What AnthMorph writes
+
+The bootstrap command prepares Claude Code with:
+
+- `ANTHROPIC_BASE_URL=http://127.0.0.1:$PORT`
+- `ANTHROPIC_AUTH_TOKEN` from `INGRESS_API_KEY` if configured, otherwise `anthmorph-local`
+- all Claude Code default model variables pointed at `PRIMARY_MODEL`
+- `API_TIMEOUT_MS=6000000`
+
+## Recommended runtime mode
+
+For Claude Code CLI usage, prefer `compat` mode.
+
+Example:
+
+```bash
+anthmorphctl init chutes --compat-mode compat
+```
+
+## Notes by backend
+
+- `chutes`: preserves Chutes-specific strengths like `top_k` and reasoning-aware routing
+- `openai_generic`: accepts Claude Code request shapes conservatively and suppresses backend-native reasoning noise by default
+
+## Verification
+
+Basic health check:
+
+```bash
+curl -fsS http://127.0.0.1:3107/health
+```
+
+Real Claude Code payload replay:
+
+```bash
+./scripts/test_claude_code_patterns_real.sh chutes
+./scripts/test_claude_code_patterns_real.sh minimax
+```

package/docs/PACKAGING.md

@@ -0,0 +1,59 @@
+# Packaging
+
+AnthMorph ships as a single npm package: `@mmmbuto/anthmorph`.
+
+## Platform model
+
+- Termux on Android/aarch64 uses the bundled prebuilt binary from `prebuilt/anthmorph`
+- Linux and macOS build from source during install
+- the supported reproducible build path is Docker
+
+The bundled prebuilt is currently **Termux-only**. Linux is supported through source builds, not a bundled Linux prebuilt.
+
+## Install behavior
+
+`postinstall` does this:
+
+- on Termux: uses the packaged prebuilt when its version matches the package version
+- on Linux/macOS: runs `cargo build --release`
+- if Cargo is missing: exits with a clear error and points to Docker-based build instructions
+
+## Docker build
+
+Build a Linux release binary without depending on host Rust:
+
+```bash
+./scripts/docker_build_linux.sh
+```
+
+This uses `rust:1.89-bookworm` and exports `/usr/local/cargo/bin` into `PATH`, which is required in this environment.
+
+## npm package contents
+
+The published package should include only:
+
+- runtime shims and CLI scripts
+- Rust sources and manifests needed for local builds
+- docs and changelog
+- the Termux prebuilt
+
+The published package should not include:
+
+- `target/`
+- local state like `.anthmorph/`
+- test output, temp logs, or tarballs
+- operator-only release scratch files
+
+## Dry-run validation
+
+Pack dry-run:
+
+```bash
+./scripts/docker_npm_dry_run.sh
+```
+
+Publish dry-run:
+
+```bash
+./scripts/docker_npm_dry_run.sh publish
+```

package/docs/RELEASE.md

@@ -0,0 +1,82 @@
+# Release Guide
+
+This guide prepares AnthMorph for GitHub push/release and npm publish without embedding credentials in the repo.
+
+## Preconditions
+
+- git identity uses `DioNanos <noreply@github.com>`
+- npm login is already configured externally
+- release auth for GitHub and npm is available in the shell, not in repo files
+- Docker is available on the release machine
+
+## Release verification
+
+Run the full Docker verification set:
+
+```bash
+./scripts/docker_release_checks.sh
+```
+
+Or step by step:
+
+```bash
+./scripts/docker_secret_scan.sh
+./scripts/docker_rust_test.sh
+./scripts/docker_build_linux.sh
+./scripts/docker_npm_dry_run.sh
+./scripts/docker_npm_dry_run.sh publish
+```
+
+## Checklist
+
+- working tree reviewed and intentional
+- `CHANGELOG.md` updated
+- versions aligned in `Cargo.toml`, `package.json`, and docs
+- Docker secret scan passes
+- Rust tests pass
+- Docker Linux build passes
+- npm pack dry-run passes
+- npm publish dry-run passes
+
+## GitHub push and tag
+
+```bash
+git status
+git add .
+git commit -m "Release v0.1.4"
+git tag -a v0.1.4 -m "Release v0.1.4"
+git push origin main
+git push origin v0.1.4
+```
+
+## GitHub release notes
+
+Use the `0.1.4` section from `CHANGELOG.md` as the release body.
+
+If `gh` is installed:
+
+```bash
+awk '
+  /^## 0.1.4$/ {capture=1; next}
+  /^## / && capture {exit}
+  capture {print}
+' CHANGELOG.md > /tmp/anthmorph-v0.1.4-notes.md
+
+gh release create v0.1.4 --title "v0.1.4" --notes-file /tmp/anthmorph-v0.1.4-notes.md
+```
+
+If `gh` is not installed, create the release in the GitHub web UI from tag `v0.1.4`.
+
+## npm publish
+
+Final publish:
+
+```bash
+npm publish --access public
+```
+
+## Notes
+
+- Do not publish from a dirty repo by accident.
+- Do not store npm tokens, GitHub tokens, or API keys in tracked files.
+- If Linux install UX changes materially, update `README.md` and `docs/PACKAGING.md` in the same release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/anthmorph",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Chutes-first Anthropic /v1/messages proxy for Chutes and OpenAI-compatible backends",
   "license": "MIT",
   "author": "DioNanos <noreply@github.com>",
@@ -12,12 +12,18 @@
     "bin/",
     "prebuilt/",
     "scripts/anthmorphctl",
+    "scripts/docker_build_linux.sh",
+    "scripts/docker_npm_dry_run.sh",
+    "scripts/docker_release_checks.sh",
+    "scripts/docker_rust_test.sh",
+    "scripts/docker_secret_scan.sh",
     "scripts/postinstall.js",
-    "scripts/smoke_test.sh",
+    "scripts/test_claude_code_patterns_real.sh",
     "src/",
-    "tests/",
+    "docs/",
     "Cargo.toml",
     "Cargo.lock",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
@@ -25,7 +31,13 @@
     "postinstall": "node scripts/postinstall.js",
     "build:rust": "cargo build --release",
     "test": "cargo test",
-    "pack:dry-run": "npm pack --dry-run"
+    "scan:secrets:docker": "sh scripts/docker_secret_scan.sh",
+    "build:docker:linux": "sh scripts/docker_build_linux.sh",
+    "test:docker": "sh scripts/docker_rust_test.sh",
+    "verify:docker": "sh scripts/docker_release_checks.sh",
+    "pack:dry-run": "npm pack --dry-run",
+    "pack:dry-run:docker": "sh scripts/docker_npm_dry_run.sh",
+    "publish:dry-run:docker": "sh scripts/docker_npm_dry_run.sh publish"
   },
   "keywords": [
     "anthropic",