@dedenlabs/claude-code-router-cli 2.0.7 → 2.0.8-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedenlabs/claude-code-router-cli",
-  "version": "2.0.7",
+  "version": "2.0.8-beta.1",
   "description": "基于@musistudio/claude-code-router的增强版CLI路由工具 - 支持统一路由引擎、外部规则加载、智能日志系统、自动配置迁移和GLM思考模式",
   "bin": {
     "ccr": "dist/cli.js"
@@ -38,17 +38,22 @@
   },
   "homepage": "https://github.com/dedenlabs/claude-code-router-cli#readme",
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.54.0",
+    "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
+    "@google/genai": "^1.7.0",
     "@inquirer/prompts": "^5.0.0",
-    "@musistudio/llms": "^1.0.48",
+    "@musistudio/llms": "^1.0.51",
     "dotenv": "^16.4.7",
     "find-process": "^2.0.0",
     "json5": "^2.2.3",
     "lru-cache": "^11.2.2",
     "minimist": "^1.2.8",
+    "openai": "^5.6.0",
     "rotating-file-stream": "^3.2.7",
     "shell-quote": "^1.8.3",
     "tiktoken": "^1.0.21",
+    "undici": "^7.10.0",
     "uuid": "^11.1.0"
   },
   "devDependencies": {

package/dist/lib/pino.js

@@ -1,234 +0,0 @@
-'use strict'
-
-const os = require('node:os')
-const stdSerializers = require('pino-std-serializers')
-const caller = require('./lib/caller')
-const redaction = require('./lib/redaction')
-const time = require('./lib/time')
-const proto = require('./lib/proto')
-const symbols = require('./lib/symbols')
-const { configure } = require('safe-stable-stringify')
-const { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = require('./lib/levels')
-const { DEFAULT_LEVELS, SORTING_ORDER } = require('./lib/constants')
-const {
-  createArgsNormalizer,
-  asChindings,
-  buildSafeSonicBoom,
-  buildFormatters,
-  stringify,
-  normalizeDestFileDescriptor,
-  noop
-} = require('./lib/tools')
-const { version } = require('./lib/meta')
-const {
-  chindingsSym,
-  redactFmtSym,
-  serializersSym,
-  timeSym,
-  timeSliceIndexSym,
-  streamSym,
-  stringifySym,
-  stringifySafeSym,
-  stringifiersSym,
-  setLevelSym,
-  endSym,
-  formatOptsSym,
-  messageKeySym,
-  errorKeySym,
-  nestedKeySym,
-  mixinSym,
-  levelCompSym,
-  useOnlyCustomLevelsSym,
-  formattersSym,
-  hooksSym,
-  nestedKeyStrSym,
-  mixinMergeStrategySym,
-  msgPrefixSym
-} = symbols
-const { epochTime, nullTime } = time
-const { pid } = process
-const hostname = os.hostname()
-const defaultErrorSerializer = stdSerializers.err
-const defaultOptions = {
-  level: 'info',
-  levelComparison: SORTING_ORDER.ASC,
-  levels: DEFAULT_LEVELS,
-  messageKey: 'msg',
-  errorKey: 'err',
-  nestedKey: null,
-  enabled: true,
-  base: { pid, hostname },
-  serializers: Object.assign(Object.create(null), {
-    err: defaultErrorSerializer
-  }),
-  formatters: Object.assign(Object.create(null), {
-    bindings (bindings) {
-      return bindings
-    },
-    level (label, number) {
-      return { level: number }
-    }
-  }),
-  hooks: {
-    logMethod: undefined,
-    streamWrite: undefined
-  },
-  timestamp: epochTime,
-  name: undefined,
-  redact: null,
-  customLevels: null,
-  useOnlyCustomLevels: false,
-  depthLimit: 5,
-  edgeLimit: 100
-}
-
-const normalize = createArgsNormalizer(defaultOptions)
-
-const serializers = Object.assign(Object.create(null), stdSerializers)
-
-function pino (...args) {
-  const instance = {}
-  const { opts, stream } = normalize(instance, caller(), ...args)
-
-  if (opts.level && typeof opts.level === 'string' && DEFAULT_LEVELS[opts.level.toLowerCase()] !== undefined) opts.level = opts.level.toLowerCase()
-
-  const {
-    redact,
-    crlf,
-    serializers,
-    timestamp,
-    messageKey,
-    errorKey,
-    nestedKey,
-    base,
-    name,
-    level,
-    customLevels,
-    levelComparison,
-    mixin,
-    mixinMergeStrategy,
-    useOnlyCustomLevels,
-    formatters,
-    hooks,
-    depthLimit,
-    edgeLimit,
-    onChild,
-    msgPrefix
-  } = opts
-
-  const stringifySafe = configure({
-    maximumDepth: depthLimit,
-    maximumBreadth: edgeLimit
-  })
-
-  const allFormatters = buildFormatters(
-    formatters.level,
-    formatters.bindings,
-    formatters.log
-  )
-
-  const stringifyFn = stringify.bind({
-    [stringifySafeSym]: stringifySafe
-  })
-  const stringifiers = redact ? redaction(redact, stringifyFn) : {}
-  const formatOpts = redact
-    ? { stringify: stringifiers[redactFmtSym] }
-    : { stringify: stringifyFn }
-  const end = '}' + (crlf ? '\r\n' : '\n')
-  const coreChindings = asChindings.bind(null, {
-    [chindingsSym]: '',
-    [serializersSym]: serializers,
-    [stringifiersSym]: stringifiers,
-    [stringifySym]: stringify,
-    [stringifySafeSym]: stringifySafe,
-    [formattersSym]: allFormatters
-  })
-
-  let chindings = ''
-  if (base !== null) {
-    if (name === undefined) {
-      chindings = coreChindings(base)
-    } else {
-      chindings = coreChindings(Object.assign({}, base, { name }))
-    }
-  }
-
-  const time = (timestamp instanceof Function)
-    ? timestamp
-    : (timestamp ? epochTime : nullTime)
-  const timeSliceIndex = time().indexOf(':') + 1
-
-  if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true')
-  if (mixin && typeof mixin !== 'function') throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`)
-  if (msgPrefix && typeof msgPrefix !== 'string') throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`)
-
-  assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
-  const levels = mappings(customLevels, useOnlyCustomLevels)
-
-  if (typeof stream.emit === 'function') {
-    stream.emit('message', { code: 'PINO_CONFIG', config: { levels, messageKey, errorKey } })
-  }
-
-  assertLevelComparison(levelComparison)
-  const levelCompFunc = genLevelComparison(levelComparison)
-
-  Object.assign(instance, {
-    levels,
-    [levelCompSym]: levelCompFunc,
-    [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
-    [streamSym]: stream,
-    [timeSym]: time,
-    [timeSliceIndexSym]: timeSliceIndex,
-    [stringifySym]: stringify,
-    [stringifySafeSym]: stringifySafe,
-    [stringifiersSym]: stringifiers,
-    [endSym]: end,
-    [formatOptsSym]: formatOpts,
-    [messageKeySym]: messageKey,
-    [errorKeySym]: errorKey,
-    [nestedKeySym]: nestedKey,
-    // protect against injection
-    [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
-    [serializersSym]: serializers,
-    [mixinSym]: mixin,
-    [mixinMergeStrategySym]: mixinMergeStrategy,
-    [chindingsSym]: chindings,
-    [formattersSym]: allFormatters,
-    [hooksSym]: hooks,
-    silent: noop,
-    onChild,
-    [msgPrefixSym]: msgPrefix
-  })
-
-  Object.setPrototypeOf(instance, proto())
-
-  genLsCache(instance)
-
-  instance[setLevelSym](level)
-
-  return instance
-}
-
-module.exports = pino
-
-module.exports.destination = (dest = process.stdout.fd) => {
-  if (typeof dest === 'object') {
-    dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd)
-    return buildSafeSonicBoom(dest)
-  } else {
-    return buildSafeSonicBoom({ dest: normalizeDestFileDescriptor(dest), minLength: 0 })
-  }
-}
-
-module.exports.transport = require('./lib/transport')
-module.exports.multistream = require('./lib/multistream')
-
-module.exports.levels = mappings()
-module.exports.stdSerializers = serializers
-module.exports.stdTimeFunctions = Object.assign({}, time)
-module.exports.symbols = symbols
-module.exports.version = version
-
-// Enables default and name export with TypeScript and Babel
-module.exports.default = pino
-module.exports.pino = pino

package/dist/lib/worker.js

@@ -1,194 +0,0 @@
-'use strict'
-
-const EE = require('node:events')
-const { pipeline, PassThrough } = require('node:stream')
-const pino = require('../pino.js')
-const build = require('pino-abstract-transport')
-const loadTransportStreamBuilder = require('./transport-stream')
-
-// This file is not checked by the code coverage tool,
-// as it is not reliable.
-
-/* istanbul ignore file */
-
-/*
- * > Multiple targets & pipelines
- *
- *
- * ┌─────────────────────────────────────────────────┐    ┌─────┐
- * │                                                 │    │  p  │
- * │                                                 │    │  i  │
- * │                   target                        │    │  n  │
- * │               │ ────────────────────────────────┼────┤  o  │
- * │   targets     │   target                        │    │  .  │
- * │ ────────────► │ ────────────────────────────────┼────┤  m  │       source
- * │               │   target                        │    │  u  │         │
- * │               │ ────────────────────────────────┼────┤  l  │         │write
- * │               │                                 │    │  t  │         ▼
- * │               │  pipeline   ┌───────────────┐   │    │  i  │      ┌────────┐
- * │               │ ──────────► │  PassThrough  ├───┼────┤  s  ├──────┤        │
- * │               │             └───────────────┘   │    │  t  │ write│ Thread │
- * │               │                                 │    │  r  │◄─────┤ Stream │
- * │               │  pipeline   ┌───────────────┐   │    │  e  │      │        │
- * │               │ ──────────► │  PassThrough  ├───┼────┤  a  │      └────────┘
- * │                             └───────────────┘   │    │  m  │
- * │                                                 │    │     │
- * └─────────────────────────────────────────────────┘    └─────┘
- *
- *
- *
- *  > One single pipeline or target
- *
- *
- *                                                           source
- *                                                             │
- * ┌────────────────────────────────────────────────┐          │write
- * │                                                │          ▼
- * │                                                │      ┌────────┐
- * │   targets     │   target                       │      │        │
- * │ ────────────► │  ──────────────────────────────┤      │        │
- * │               │                                │      │        │
- * │                                                ├──────┤        │
- * │                                                │      │        │
- * │                                                │      │        │
- * │                     OR                         │      │        │
- * │                                                │      │        │
- * │                                                │      │        │
- * │                               ┌──────────────┐ │      │        │
- * │   targets     │   pipeline    │              │ │      │ Thread │
- * │ ────────────► │  ────────────►│ PassThrough  ├─┤      │ Stream │
- * │               │               │              │ │      │        │
- * │                               └──────────────┘ │      │        │
- * │                                                │      │        │
- * │                     OR                         │ write│        │
- * │                                                │◄─────┤        │
- * │                                                │      │        │
- * │                ┌──────────────┐                │      │        │
- * │    pipeline    │              │                │      │        │
- * │ ──────────────►│ PassThrough  ├────────────────┤      │        │
- * │                │              │                │      │        │
- * │                └──────────────┘                │      └────────┘
- * │                                                │
- * │                                                │
- * └────────────────────────────────────────────────┘
- */
-
-module.exports = async function ({ targets, pipelines, levels, dedupe }) {
-  const targetStreams = []
-
-  // Process targets
-  if (targets && targets.length) {
-    targets = await Promise.all(targets.map(async (t) => {
-      const fn = await loadTransportStreamBuilder(t.target)
-      const stream = await fn(t.options)
-      return {
-        level: t.level,
-        stream
-      }
-    }))
-
-    targetStreams.push(...targets)
-  }
-
-  // Process pipelines
-  if (pipelines && pipelines.length) {
-    pipelines = await Promise.all(
-      pipelines.map(async (p) => {
-        let level
-        const pipeDests = await Promise.all(
-          p.map(async (t) => {
-            // level assigned to pipeline is duplicated over all its targets, just store it
-            level = t.level
-            const fn = await loadTransportStreamBuilder(t.target)
-            const stream = await fn(t.options)
-            return stream
-          }
-          ))
-
-        return {
-          level,
-          stream: createPipeline(pipeDests)
-        }
-      })
-    )
-    targetStreams.push(...pipelines)
-  }
-
-  // Skip building the multistream step if either one single pipeline or target is defined and
-  // return directly the stream instance back to TreadStream.
-  // This is equivalent to define either:
-  //
-  // pino.transport({ target: ... })
-  //
-  // OR
-  //
-  // pino.transport({ pipeline: ... })
-  if (targetStreams.length === 1) {
-    return targetStreams[0].stream
-  } else {
-    return build(process, {
-      parse: 'lines',
-      metadata: true,
-      close (err, cb) {
-        let expected = 0
-        for (const transport of targetStreams) {
-          expected++
-          transport.stream.on('close', closeCb)
-          transport.stream.end()
-        }
-
-        function closeCb () {
-          if (--expected === 0) {
-            cb(err)
-          }
-        }
-      }
-    })
-  }
-
-  // TODO: Why split2 was not used for pipelines?
-  function process (stream) {
-    const multi = pino.multistream(targetStreams, { levels, dedupe })
-    // TODO manage backpressure
-    stream.on('data', function (chunk) {
-      const { lastTime, lastMsg, lastObj, lastLevel } = this
-      multi.lastLevel = lastLevel
-      multi.lastTime = lastTime
-      multi.lastMsg = lastMsg
-      multi.lastObj = lastObj
-
-      // TODO handle backpressure
-      multi.write(chunk + '\n')
-    })
-  }
-
-  /**
- * Creates a pipeline using the provided streams and return an instance of `PassThrough` stream
- * as a source for the pipeline.
- *
- * @param {(TransformStream|WritableStream)[]} streams An array of streams.
- *   All intermediate streams in the array *MUST* be `Transform` streams and only the last one `Writable`.
- * @returns A `PassThrough` stream instance representing the source stream of the pipeline
- */
-  function createPipeline (streams) {
-    const ee = new EE()
-    const stream = new PassThrough({
-      autoDestroy: true,
-      destroy (_, cb) {
-        ee.on('error', cb)
-        ee.on('closed', cb)
-      }
-    })
-
-    pipeline(stream, ...streams, function (err) {
-      if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-        ee.emit('error', err)
-        return
-      }
-
-      ee.emit('closed')
-    })
-
-    return stream
-  }
-}