@mmmbuto/anthmorph 0.1.0

package/scripts/anthmorphctl

@@ -0,0 +1,456 @@
+#!/bin/sh
+set -eu
+
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+STATE_DIR=${ANTHMORPH_STATE_DIR:-$ROOT_DIR/.anthmorph}
+CONFIG_FILE=$STATE_DIR/config.env
+PID_FILE=$STATE_DIR/anthmorph.pid
+LOG_FILE=$STATE_DIR/anthmorph.log
+BIN_PATH_DEFAULT=$ROOT_DIR/target/release/anthmorph
+
+mkdir -p "$STATE_DIR"
+
+usage() {
+  cat <<USAGE
+usage:
+  scripts/anthmorphctl init chutes [options]
+  scripts/anthmorphctl init minimax [options]
+  scripts/anthmorphctl init openai --backend-url URL --model MODEL [options]
+  scripts/anthmorphctl set key-env ENV_NAME
+  scripts/anthmorphctl set key VALUE --save
+  scripts/anthmorphctl unset key
+  scripts/anthmorphctl start
+  scripts/anthmorphctl stop
+  scripts/anthmorphctl restart
+  scripts/anthmorphctl status
+  scripts/anthmorphctl logs
+  scripts/anthmorphctl print-config
+  scripts/anthmorphctl help
+
+options for init:
+  --port PORT
+  --backend-url URL
+  --model MODEL
+  --reasoning-model MODEL
+  --ingress-api-key VALUE
+  --allow-origin ORIGIN
+  --key-env ENV_NAME
+  --api-key VALUE --save-key
+
+notes:
+  - by default the API key is not saved; use set key-env or --key-env
+  - set key VALUE --save stores the key in the local config file
+  - config lives in .anthmorph/config.env
+USAGE
+}
+
+ensure_config() {
+  if [ ! -f "$CONFIG_FILE" ]; then
+    echo "missing config: run 'scripts/anthmorphctl init ...' first" >&2
+    exit 1
+  fi
+}
+
+load_config() {
+  ensure_config
+  # shellcheck disable=SC1090
+  . "$CONFIG_FILE"
+}
+
+save_config() {
+  tmp_file=$CONFIG_FILE.tmp
+  {
+    printf 'BACKEND_PROFILE=%s\n' "${BACKEND_PROFILE:-}"
+    printf 'BACKEND_URL=%s\n' "${BACKEND_URL:-}"
+    printf 'MODEL=%s\n' "${MODEL:-}"
+    printf 'REASONING_MODEL=%s\n' "${REASONING_MODEL:-}"
+    printf 'PORT=%s\n' "${PORT:-3000}"
+    printf 'INGRESS_API_KEY=%s\n' "${INGRESS_API_KEY:-}"
+    printf 'ALLOWED_ORIGINS=%s\n' "${ALLOWED_ORIGINS:-}"
+    printf 'API_KEY_ENV=%s\n' "${API_KEY_ENV:-}"
+    printf 'API_KEY=%s\n' "${API_KEY:-}"
+    printf 'BIN_PATH=%s\n' "${BIN_PATH:-$BIN_PATH_DEFAULT}"
+  } > "$tmp_file"
+  mv "$tmp_file" "$CONFIG_FILE"
+}
+
+is_running() {
+  [ -f "$PID_FILE" ] || return 1
+  pid=$(cat "$PID_FILE" 2>/dev/null || true)
+  [ -n "$pid" ] || return 1
+  kill -0 "$pid" 2>/dev/null
+}
+
+resolve_api_key() {
+  if [ -n "${API_KEY:-}" ]; then
+    printf '%s' "$API_KEY"
+    return 0
+  fi
+
+  if [ -n "${API_KEY_ENV:-}" ]; then
+    eval "resolved=\${$API_KEY_ENV-}"
+    if [ -n "${resolved:-}" ]; then
+      printf '%s' "$resolved"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
+health_on_port() {
+  curl -fsS "http://127.0.0.1:$1/health" 2>/dev/null
+}
+
+join_allow_origin() {
+  value=$1
+  if [ -z "${ALLOWED_ORIGINS:-}" ]; then
+    ALLOWED_ORIGINS=$value
+  else
+    ALLOWED_ORIGINS=${ALLOWED_ORIGINS},$value
+  fi
+}
+
+parse_common_init_args() {
+  SAVE_KEY=0
+  while [ "$#" -gt 0 ]; do
+    case "$1" in
+      --port)
+        PORT=$2
+        shift 2
+        ;;
+      --backend-url)
+        BACKEND_URL=$2
+        shift 2
+        ;;
+      --model)
+        MODEL=$2
+        shift 2
+        ;;
+      --reasoning-model)
+        REASONING_MODEL=$2
+        shift 2
+        ;;
+      --ingress-api-key)
+        INGRESS_API_KEY=$2
+        shift 2
+        ;;
+      --allow-origin)
+        join_allow_origin "$2"
+        shift 2
+        ;;
+      --key-env)
+        API_KEY_ENV=$2
+        shift 2
+        ;;
+      --api-key)
+        API_KEY=$2
+        shift 2
+        ;;
+      --save-key)
+        SAVE_KEY=1
+        shift
+        ;;
+      *)
+        echo "unknown option: $1" >&2
+        exit 1
+        ;;
+    esac
+  done
+
+  if [ "$SAVE_KEY" -ne 1 ]; then
+    API_KEY=
+  fi
+}
+
+init_cmd() {
+  preset=${1:-}
+  [ -n "$preset" ] || {
+    echo "missing preset" >&2
+    usage
+    exit 1
+  }
+  shift
+
+  BACKEND_PROFILE=
+  BACKEND_URL=
+  MODEL=
+  REASONING_MODEL=
+  PORT=3000
+  INGRESS_API_KEY=
+  ALLOWED_ORIGINS=
+  API_KEY_ENV=
+  API_KEY=
+  BIN_PATH=$BIN_PATH_DEFAULT
+
+  case "$preset" in
+    chutes)
+      BACKEND_PROFILE=chutes
+      BACKEND_URL=https://llm.chutes.ai/v1
+      MODEL=Qwen/Qwen3-Coder-Next-TEE
+      API_KEY_ENV=CHUTES_API_KEY
+      ;;
+    minimax)
+      BACKEND_PROFILE=openai-generic
+      BACKEND_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/v1}
+      MODEL=${MINIMAX_MODEL:-MiniMax-M2.5}
+      API_KEY_ENV=MINIMAX_API_KEY
+      ;;
+    openai)
+      BACKEND_PROFILE=openai-generic
+      ;;
+    *)
+      echo "unsupported preset: $preset" >&2
+      exit 1
+      ;;
+  esac
+
+  parse_common_init_args "$@"
+
+  if [ -z "$BACKEND_URL" ] || [ -z "$MODEL" ] || [ -z "$BACKEND_PROFILE" ]; then
+    echo "backend profile, backend url and model are required" >&2
+    exit 1
+  fi
+
+  if [ -n "$API_KEY" ] && [ -n "$API_KEY_ENV" ]; then
+    API_KEY_ENV=
+  fi
+
+  save_config
+  echo "saved config to $CONFIG_FILE"
+}
+
+set_cmd() {
+  ensure_config
+  load_config
+  field=${1:-}
+  [ -n "$field" ] || {
+    echo "missing field" >&2
+    exit 1
+  }
+  shift
+
+  case "$field" in
+    key-env)
+      API_KEY_ENV=${1:-}
+      [ -n "$API_KEY_ENV" ] || {
+        echo "missing env name" >&2
+        exit 1
+      }
+      API_KEY=
+      ;;
+    key)
+      value=${1:-}
+      [ -n "$value" ] || {
+        echo "missing key value" >&2
+        exit 1
+      }
+      shift
+      save_flag=${1:-}
+      if [ "$save_flag" = "--save" ]; then
+        API_KEY=$value
+        API_KEY_ENV=
+      else
+        echo "use: scripts/anthmorphctl set key VALUE --save" >&2
+        exit 1
+      fi
+      ;;
+    *)
+      echo "unsupported field: $field" >&2
+      exit 1
+      ;;
+  esac
+
+  save_config
+  echo "updated $field"
+}
+
+unset_cmd() {
+  ensure_config
+  load_config
+  field=${1:-}
+  case "$field" in
+    key)
+      API_KEY=
+      API_KEY_ENV=
+      ;;
+    *)
+      echo "unsupported unset field: $field" >&2
+      exit 1
+      ;;
+  esac
+  save_config
+  echo "cleared $field"
+}
+
+start_cmd() {
+  load_config
+
+  if is_running; then
+    echo "already running (pid $(cat "$PID_FILE"))"
+    return 0
+  fi
+
+  if health_on_port "$PORT" >/dev/null; then
+    echo "port $PORT is already serving an AnthMorph-compatible health endpoint" >&2
+    echo "use a different port with 'scripts/anthmorphctl init ... --port PORT'" >&2
+    exit 1
+  fi
+
+  if [ ! -x "$BIN_PATH" ]; then
+    (cd "$ROOT_DIR" && cargo build --release --quiet)
+  fi
+
+  api_key=$(resolve_api_key || true)
+  if [ -z "$api_key" ]; then
+    echo "missing API key: configure API_KEY_ENV or save an API key" >&2
+    exit 1
+  fi
+
+  set -- "$BIN_PATH" \
+    --port "$PORT" \
+    --backend-profile "$BACKEND_PROFILE" \
+    --backend-url "$BACKEND_URL" \
+    --model "$MODEL" \
+    --api-key "$api_key"
+
+  if [ -n "${REASONING_MODEL:-}" ]; then
+    set -- "$@" --reasoning-model "$REASONING_MODEL"
+  fi
+  if [ -n "${INGRESS_API_KEY:-}" ]; then
+    set -- "$@" --ingress-api-key "$INGRESS_API_KEY"
+  fi
+
+  old_ifs=${IFS:- }
+  IFS=,
+  for origin in ${ALLOWED_ORIGINS:-}; do
+    [ -n "$origin" ] || continue
+    set -- "$@" --allow-origin "$origin"
+  done
+  IFS=$old_ifs
+
+  nohup "$@" >>"$LOG_FILE" 2>&1 &
+  pid=$!
+  echo "$pid" > "$PID_FILE"
+  sleep 1
+
+  if kill -0 "$pid" 2>/dev/null; then
+    echo "started anthmorph (pid $pid)"
+  else
+    echo "failed to start; see $LOG_FILE" >&2
+    rm -f "$PID_FILE"
+    exit 1
+  fi
+}
+
+stop_cmd() {
+  if ! is_running; then
+    rm -f "$PID_FILE"
+    echo "not running"
+    return 0
+  fi
+
+  pid=$(cat "$PID_FILE")
+  kill "$pid" 2>/dev/null || true
+  for _ in 1 2 3 4 5 6 7 8 9 10; do
+    if ! kill -0 "$pid" 2>/dev/null; then
+      rm -f "$PID_FILE"
+      echo "stopped anthmorph"
+      return 0
+    fi
+    sleep 1
+  done
+  kill -9 "$pid" 2>/dev/null || true
+  rm -f "$PID_FILE"
+  echo "killed anthmorph"
+}
+
+status_cmd() {
+  load_config
+  if is_running; then
+    pid=$(cat "$PID_FILE")
+    health=$(health_on_port "$PORT" || true)
+    echo "status: running"
+    echo "pid: $pid"
+    echo "health: ${health:-unreachable}"
+  else
+    health=$(health_on_port "$PORT" || true)
+    if [ -n "$health" ]; then
+      echo "status: external-process-on-port"
+      echo "health: $health"
+    else
+      echo "status: stopped"
+    fi
+  fi
+  echo "profile: ${BACKEND_PROFILE:-}"
+  echo "backend_url: ${BACKEND_URL:-}"
+  echo "model: ${MODEL:-}"
+  echo "port: ${PORT:-}"
+  if [ -n "${API_KEY_ENV:-}" ]; then
+    key_source=env:$API_KEY_ENV
+  elif [ -n "${API_KEY:-}" ]; then
+    key_source=saved
+  else
+    key_source=missing
+  fi
+  echo "key_source: $key_source"
+  echo "log_file: $LOG_FILE"
+  echo "config_file: $CONFIG_FILE"
+}
+
+logs_cmd() {
+  if [ -f "$LOG_FILE" ]; then
+    tail -n 80 "$LOG_FILE"
+  else
+    echo "log file not found: $LOG_FILE" >&2
+    exit 1
+  fi
+}
+
+print_config_cmd() {
+  ensure_config
+  sed '/^API_KEY=/s/=.*/=<hidden>/;/^INGRESS_API_KEY=/s/=.*/=<hidden>/' "$CONFIG_FILE"
+}
+
+cmd=${1:-help}
+case "$cmd" in
+  init)
+    shift
+    init_cmd "$@"
+    ;;
+  set)
+    shift
+    set_cmd "$@"
+    ;;
+  unset)
+    shift
+    unset_cmd "$@"
+    ;;
+  start)
+    start_cmd
+    ;;
+  stop)
+    stop_cmd
+    ;;
+  restart)
+    stop_cmd
+    start_cmd
+    ;;
+  status)
+    status_cmd
+    ;;
+  logs)
+    logs_cmd
+    ;;
+  print-config)
+    print_config_cmd
+    ;;
+  help|-h|--help)
+    usage
+    ;;
+  *)
+    echo "unknown command: $cmd" >&2
+    usage >&2
+    exit 1
+    ;;
+esac

package/scripts/postinstall.js

@@ -0,0 +1,23 @@
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+const root = path.resolve(__dirname, "..");
+
+function hasCargo() {
+  const probe = spawnSync("cargo", ["--version"], { stdio: "ignore" });
+  return probe.status === 0;
+}
+
+if (!hasCargo()) {
+  console.log("[anthmorph] cargo not found; skipping Rust build");
+  process.exit(0);
+}
+
+const build = spawnSync("cargo", ["build", "--release", "--quiet"], {
+  cwd: root,
+  stdio: "inherit",
+});
+
+if (build.status !== 0) {
+  process.exit(build.status || 1);
+}

package/scripts/smoke_test.sh

@@ -0,0 +1,72 @@
+#!/bin/sh
+set -eu
+
+BACKEND=${1:?usage: ./scripts/smoke_test.sh <chutes|alibaba|minimax>}
+PORT=${SMOKE_PORT:-3101}
+PROMPT=${SMOKE_PROMPT:-Reply with exactly: anthmorph-smoke-ok}
+LOG_FILE=${TMPDIR:-/tmp}/anthmorph-smoke-${BACKEND}-${PORT}.log
+RESPONSE_FILE=${TMPDIR:-/tmp}/anthmorph-smoke-${BACKEND}-${PORT}.json
+
+case "$BACKEND" in
+  chutes)
+    PROFILE=chutes
+    BACKEND_URL=${CHUTES_BASE_URL:-https://llm.chutes.ai/v1}
+    MODEL=${CHUTES_MODEL:-Qwen/Qwen3-Coder-Next-TEE}
+    API_KEY=${CHUTES_API_KEY:?CHUTES_API_KEY is required}
+    ;;
+  alibaba)
+    PROFILE=openai-generic
+    BACKEND_URL=${ALIBABA_BASE_URL:-https://coding-intl.dashscope.aliyuncs.com/v1}
+    MODEL=${ALIBABA_MODEL:-qwen3-coder-plus}
+    API_KEY=${ALIBABA_CODE_API_KEY:?ALIBABA_CODE_API_KEY is required}
+    ;;
+  minimax)
+    PROFILE=openai-generic
+    BACKEND_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/v1}
+    MODEL=${MINIMAX_MODEL:-MiniMax-M2.5}
+    API_KEY=${MINIMAX_API_KEY:?MINIMAX_API_KEY is required}
+    ;;
+  *)
+    echo "unsupported backend: $BACKEND" >&2
+    exit 2
+    ;;
+esac
+
+cleanup() {
+  if [ -n "${SERVER_PID:-}" ] && kill -0 "$SERVER_PID" 2>/dev/null; then
+    kill "$SERVER_PID" 2>/dev/null || true
+    wait "$SERVER_PID" 2>/dev/null || true
+  fi
+}
+trap cleanup EXIT INT TERM
+
+if [ ! -x ./target/debug/anthmorph ]; then
+  cargo build --quiet
+fi
+
+./target/debug/anthmorph   --port "$PORT"   --backend-profile "$PROFILE"   --backend-url "$BACKEND_URL"   --model "$MODEL"   --api-key "$API_KEY"   >"$LOG_FILE" 2>&1 &
+SERVER_PID=$!
+
+READY=0
+for _ in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30; do
+  if curl -fsS "http://127.0.0.1:$PORT/health" >/dev/null 2>&1; then
+    READY=1
+    break
+  fi
+  sleep 1
+done
+
+if [ "$READY" -ne 1 ]; then
+  echo "server did not become ready; log follows:" >&2
+  cat "$LOG_FILE" >&2
+  exit 1
+fi
+
+PAYLOAD=$(cat <<EOF
+{"model":"claude-sonnet-4","max_tokens":128,"messages":[{"role":"user","content":"$PROMPT"}]}
+EOF
+)
+
+curl -fsS "http://127.0.0.1:$PORT/v1/messages"   -H 'content-type: application/json'   -d "$PAYLOAD"   >"$RESPONSE_FILE"
+
+cat "$RESPONSE_FILE"

package/src/config.rs

@@ -0,0 +1,39 @@
+use clap::ValueEnum;
+use std::str::FromStr;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+pub enum BackendProfile {
+    Chutes,
+    OpenaiGeneric,
+}
+
+impl BackendProfile {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            BackendProfile::Chutes => "chutes",
+            BackendProfile::OpenaiGeneric => "openai_generic",
+        }
+    }
+
+    pub fn supports_top_k(self) -> bool {
+        matches!(self, BackendProfile::Chutes)
+    }
+
+    pub fn supports_reasoning(self) -> bool {
+        matches!(self, BackendProfile::Chutes)
+    }
+}
+
+impl FromStr for BackendProfile {
+    type Err = String;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value.trim().to_ascii_lowercase().as_str() {
+            "chutes" => Ok(Self::Chutes),
+            "openai_generic" | "openai-generic" | "openai" | "generic" => Ok(Self::OpenaiGeneric),
+            other => Err(format!(
+                "unsupported backend profile '{other}', expected 'chutes' or 'openai_generic'"
+            )),
+        }
+    }
+}

package/src/error.rs

@@ -0,0 +1,54 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ProxyError {
+    #[error("HTTP error: {0}")]
+    Http(#[from] reqwest::Error),
+
+    #[error("Upstream error: {0}")]
+    Upstream(String),
+
+    #[error("Transform error: {0}")]
+    Transform(String),
+
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+}
+
+impl axum::response::IntoResponse for ProxyError {
+    fn into_response(self) -> axum::response::Response {
+        use axum::http::StatusCode;
+
+        let (status, error_type) = match &self {
+            ProxyError::Http(_) => (StatusCode::BAD_GATEWAY, "api_error"),
+            ProxyError::Upstream(msg) => {
+                if msg.contains("401") || msg.contains("403") {
+                    (StatusCode::UNAUTHORIZED, "authentication_error")
+                } else if msg.contains("429") {
+                    (StatusCode::TOO_MANY_REQUESTS, "rate_limit_error")
+                } else if msg.contains("404") {
+                    (StatusCode::NOT_FOUND, "not_found_error")
+                } else {
+                    (StatusCode::BAD_GATEWAY, "api_error")
+                }
+            }
+            ProxyError::Transform(_) => (StatusCode::BAD_REQUEST, "invalid_request_error"),
+            ProxyError::Serialization(_) => (StatusCode::BAD_REQUEST, "invalid_request_error"),
+            ProxyError::Io(_) => (StatusCode::INTERNAL_SERVER_ERROR, "api_error"),
+        };
+
+        let payload = serde_json::json!({
+            "type": "error",
+            "error": {
+                "type": error_type,
+                "message": self.to_string()
+            }
+        });
+        (status, axum::Json(payload)).into_response()
+    }
+}
+
+pub type ProxyResult<T> = Result<T, ProxyError>;