@ljwei-stak/dsh-model-router 0.13.0

package/.dsh-plugin/shared/vendor-minimax-adapter.mjs

@@ -0,0 +1,247 @@
+/**
+ * MiniMax Code 0.5.5 headless adapter.
+ *
+ * Source contracts:
+ * https://github.com/MiniMax-AI/minimax-code/blob/v0.5.5/packages/tui/src/cli/contract.ts
+ * https://github.com/MiniMax-AI/minimax-code/blob/v0.5.5/packages/tui/src/headless/events.ts
+ * https://github.com/MiniMax-AI/minimax-code/blob/v0.5.5/packages/tui/src/headless/contract.ts
+ *
+ * The Host verifies the official npm bundle, Node runtime, account, and
+ * workspace. This module never resolves a PATH shim or accepts free-form args.
+ */
+import { basename, isAbsolute } from 'node:path'
+
+const TYPES = new Set([
+  'exec.started', 'session.started', 'session.resumed', 'turn.started',
+  'item.started', 'item.updated', 'item.completed',
+  'turn.completed', 'turn.failed', 'exec.completed',
+])
+const STATUSES = new Set(['succeeded', 'failed', 'timeout', 'cancelled', 'limit_exceeded'])
+
+function object(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function id(value, maximum = 240) {
+  return typeof value === 'string' && value.length > 0 && value.length <= maximum && !value.includes('\0')
+}
+
+function absolute(value, label, filename) {
+  if (typeof value !== 'string' || !isAbsolute(value) || value.includes('\0')) {
+    throw new TypeError(label + ' must be an absolute path')
+  }
+  if (filename && basename(value).toLowerCase() !== filename) {
+    throw new TypeError(label + ' must identify ' + filename)
+  }
+  return value
+}
+
+function checkedModel(value) {
+  if (value == null || value === '') return null
+  if (typeof value !== 'string' || value.length > 240 || value.includes('\0')
+    || !/^[A-Za-z0-9][A-Za-z0-9_.:-]*\/[A-Za-z0-9][A-Za-z0-9_.:/#-]*$/.test(value)) {
+    throw new TypeError('MiniMax model must use provider/model')
+  }
+  return value
+}
+
+/**
+ * Build the fixed invocation. The caller sends the task on stdin. MiniMax
+ * headless has no read-only switch: the outer Host sandbox enforces that mode.
+ * Full vendor permission is available only for a Host-approved isolated run.
+ */
+export function buildMiniMaxInvocation({
+  nodeExecutable, cliEntry, workspace, mode = 'read-only',
+  modelReference, permission = 'smart', timeoutMs, maxSteps,
+}) {
+  const file = absolute(nodeExecutable, 'nodeExecutable', process.platform === 'win32' ? 'node.exe' : 'node')
+  const entry = absolute(cliEntry, 'cliEntry', 'cli.js')
+  const cwd = absolute(workspace, 'workspace')
+  if (mode !== 'read-only' && mode !== 'workspace-write') throw new TypeError('invalid execution mode')
+  if (permission !== 'smart' && permission !== 'full') throw new TypeError('invalid MiniMax permission')
+  if (permission === 'full' && mode !== 'workspace-write') {
+    throw new TypeError('full MiniMax permission requires an isolated workspace-write run')
+  }
+  const model = checkedModel(modelReference)
+  if (timeoutMs !== undefined && (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1_000 || timeoutMs > 86_400_000)) {
+    throw new TypeError('timeoutMs must be between 1000 and 86400000')
+  }
+  if (maxSteps !== undefined && (!Number.isSafeInteger(maxSteps) || maxSteps < 1 || maxSteps > 10_000)) {
+    throw new TypeError('maxSteps must be between 1 and 10000')
+  }
+  const args = [entry, 'exec', '--input', '-', '--cwd', cwd,
+    '--permission', permission, '--output-format', 'stream-json']
+  if (model) args.push('--model', model)
+  if (timeoutMs !== undefined) args.push('--timeout', String(timeoutMs) + 'ms')
+  if (maxSteps !== undefined) args.push('--max-steps', String(maxSteps))
+  return { file, args, format: 'minimax-stream-json',
+    source: 'verified-official-npm-bundle', requestedModel: model }
+}
+
+function validUsage(value) {
+  return value === undefined || (object(value) && Object.values(value).every(
+    field => field === undefined || (typeof field === 'number' && Number.isFinite(field) && field >= 0)))
+}
+
+function validModel(value) {
+  return value === undefined || (object(value) && id(value.providerId) && id(value.modelId))
+}
+
+function validResult(value) {
+  return object(value) && value.schemaVersion === 1 && value.type === 'exec.result'
+    && id(value.runId) && id(value.sessionId) && id(value.turnId)
+    && STATUSES.has(value.status) && Number.isFinite(value.durationMs)
+    && value.durationMs >= 0 && validModel(value.model) && validUsage(value.usage)
+    && (value.usageSource === undefined || [
+      'completed_responses', 'analytics_fallback', 'unavailable',
+    ].includes(value.usageSource))
+    && (value.usageIncomplete === undefined || typeof value.usageIncomplete === 'boolean')
+    && (value.error === undefined || (object(value.error)
+      && ['config', 'runtime', 'internal'].includes(value.error.category)
+      && typeof value.error.message === 'string'))
+}
+
+function answer(result, lastMessage) {
+  if (typeof result.output === 'string') return result.output
+  if (result.output !== undefined && result.output !== null) {
+    try { return JSON.stringify(result.output) } catch { /* malformed vendor payload */ }
+  }
+  return lastMessage
+}
+
+/**
+ * Call push with decoded UTF-8 stdout and finish after close. Only a valid
+ * exec.completed result, matching turn terminal, and exit code 0 succeeds.
+ */
+export function createMiniMaxStreamParser({ maxLineChars = 4_000_000 } = {}) {
+  if (!Number.isSafeInteger(maxLineChars) || maxLineChars < 1024 || maxLineChars > 16_000_000) {
+    throw new TypeError('maxLineChars is out of range')
+  }
+  let pending = ''
+  let error = null
+  let sequence = 0
+  let identity = null
+  let stage = 'initial'
+  let terminal = null
+  let terminalStatus = null
+  let result = null
+  let lastMessage = ''
+
+  function reject(message) { error ??= message }
+
+  function accept(line) {
+    if (error || !line.trim()) return
+    let event
+    try { event = JSON.parse(line) } catch { reject('MiniMax 输出了无效 JSONL。'); return }
+    if (!object(event) || event.schemaVersion !== 1 || !TYPES.has(event.type)
+      || !Number.isSafeInteger(event.sequence) || event.sequence !== sequence + 1
+      || !Number.isFinite(event.timestampMs) || event.timestampMs < 0
+      || !id(event.runId) || !id(event.sessionId) || !id(event.turnId)) {
+      reject('MiniMax JSONL 事件结构或顺序无效。')
+      return
+    }
+    sequence = event.sequence
+    const current = { runId: event.runId, sessionId: event.sessionId, turnId: event.turnId }
+    if (identity && Object.keys(current).some(key => current[key] !== identity[key])) {
+      reject('MiniMax 会话身份在运行中改变。')
+      return
+    }
+    identity ??= current
+    if (stage === 'finished' || (terminal && event.type !== 'exec.completed')) {
+      reject('MiniMax 在终态后继续输出事件。')
+      return
+    }
+    if (stage === 'initial') {
+      if (event.type === 'exec.started') stage = 'started'
+      else reject('MiniMax 缺少 exec.started 起始事件。')
+      return
+    }
+    if (event.type === 'session.started' || event.type === 'session.resumed') {
+      if (stage === 'started') stage = 'session'
+      else reject('MiniMax 会话起始事件顺序无效。')
+      return
+    }
+    if (event.type === 'turn.started') {
+      if (stage === 'session') stage = 'turn'
+      else reject('MiniMax turn.started 事件顺序无效。')
+      return
+    }
+    if (stage !== 'turn') { reject('MiniMax 缺少会话或任务起始事件。'); return }
+    if (event.type.startsWith('item.')) {
+      if (!object(event.item) || !id(event.item.id, 500)
+        || !['agent_message', 'reasoning', 'tool_call'].includes(event.item.type)) {
+        reject('MiniMax item 事件结构无效。')
+      } else if (event.type === 'item.completed' && event.item.type === 'agent_message'
+        && typeof event.item.content === 'string') {
+        lastMessage = event.item.content
+      }
+      return
+    }
+    if (event.type === 'turn.completed' || event.type === 'turn.failed') {
+      if (!Number.isFinite(event.durationMs) || event.durationMs < 0
+        || (event.type === 'turn.failed'
+          && (!STATUSES.has(event.status) || event.status === 'succeeded'))) {
+        reject('MiniMax turn 终态结构无效。')
+      } else {
+        terminal = event.type
+        terminalStatus = event.type === 'turn.completed' ? 'succeeded' : event.status
+      }
+      return
+    }
+    if (event.type === 'exec.completed') {
+      if (!terminal || !validResult(event.result)
+        || Object.keys(identity).some(key => event.result[key] !== identity[key])
+        || event.result.status !== terminalStatus) {
+        reject('MiniMax exec.completed 与任务终态不一致。')
+      } else {
+        result = event.result
+        stage = 'finished'
+      }
+      return
+    }
+    reject('MiniMax JSONL 出现意外事件。')
+  }
+
+  return {
+    push(chunk) {
+      if (typeof chunk !== 'string') throw new TypeError('push expects decoded UTF-8 text')
+      if (error) return { events: sequence, protocolError: error }
+      pending += chunk
+      for (;;) {
+        const newline = pending.indexOf('\n')
+        if (newline < 0) break
+        const line = pending.slice(0, newline).replace(/\r$/, '')
+        pending = pending.slice(newline + 1)
+        if (line.length > maxLineChars) { reject('MiniMax JSONL 单行超出限制。'); break }
+        accept(line)
+        if (error) break
+      }
+      if (!error && pending.length > maxLineChars) reject('MiniMax JSONL 单行超出限制。')
+      if (error) pending = ''
+      return { events: sequence, protocolError: error }
+    },
+    finish(exitCode) {
+      if (!error && pending.trim()) accept(pending.replace(/\r$/, ''))
+      pending = ''
+      if (error) return { status: 'failed', exitCode, error, terminalEvent: terminal }
+      if (!result || !terminal || stage !== 'finished') {
+        return { status: 'failed', exitCode, error: 'MiniMax 未返回完整的 exec.completed 结果。', terminalEvent: terminal }
+      }
+      const finalText = answer(result, lastMessage)
+      const details = {
+        exitCode, vendorStatus: result.status, terminalEvent: terminal,
+        runId: result.runId, sessionId: result.sessionId, turnId: result.turnId,
+        reportedModel: result.model ?? null, usage: result.usage ?? null,
+        usageSource: result.usageSource ?? null,
+        usageIncomplete: result.usageIncomplete ?? null,
+        durationMs: result.durationMs, finalText,
+      }
+      if (exitCode !== 0) return { ...details, status: 'failed', error: 'MiniMax CLI 退出码非零。' }
+      if (result.status !== 'succeeded') {
+        return { ...details, status: 'failed',
+          error: String(result.error?.message ?? result.status).slice(0, 500) }
+      }
+      return { ...details, status: 'succeeded' }
+    },
+  }
+}

package/.dsh-plugin/shared/zcode-bundle.mjs

@@ -0,0 +1,208 @@
+/**
+ * Locate the pinned ZCode desktop bundle on Windows without trusting PATH.
+ *
+ * Discovery accepts a deliberate operator override, Windows uninstall records,
+ * and the conventional installation directories. An install is usable only if
+ * its canonical ZCode.exe has a valid signature from the expected publisher,
+ * its signed product version is 3.14.3, and the bundled GLM entry remains
+ * inside that same canonical installation root.
+ */
+import { execFile } from 'node:child_process'
+import { createReadStream } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { realpath, stat } from 'node:fs/promises'
+import { promisify } from 'node:util'
+import { dirname, isAbsolute, join, relative, sep, win32 } from 'node:path'
+
+const execFileAsync = promisify(execFile)
+
+export const ZCODE_SUPPORTED_VERSION = '3.14.3'
+export const ZCODE_SIGNER = '北京智谱华章科技股份有限公司'
+export const ZCODE_INSTALL_ENV_VAR = 'MODEL_ROUTER_ZCODE_HOME'
+export const ZCODE_WINDOWS_INSTALLER_URL =
+  'https://cdn-zcode.z.ai/zcode/electron/releases/3.14.3/windows-x64/ZCode-3.14.3-win-x64.exe'
+export const ZCODE_WINDOWS_INSTALLER_SHA256 =
+  '404895B46DD1E3066B10A9AB9C187CA07F3082AFC8E108A9D02D86B87186CB93'
+// Extracted from the hash-checked, Authenticode-valid pinned Windows installer.
+// The Desktop EXE signature alone does not authenticate this mutable JS file.
+export const ZCODE_CLI_SHA256 =
+  'B1DF2EF3E5BD76C4AF3ECB296BC003A10D3F13191A26610BD0BA940FEADAD529'
+const ZCODE_CLI_SIZE = 14_820_819
+
+const REGISTRY_PATHS = Object.freeze([
+  'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+  'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+  'HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+])
+
+function powershellPath(env) {
+  const systemRoot = env.SystemRoot || env.windir || 'C:\\Windows'
+  return join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+}
+
+async function powershellJson(script, env, extraEnv = {}) {
+  if (process.platform !== 'win32') return null
+  const command = Buffer.from(
+    '[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false); '
+      + '$ErrorActionPreference = "Stop"; ' + script,
+    'utf16le',
+  ).toString('base64')
+  try {
+    const { stdout } = await execFileAsync(powershellPath(env), [
+      '-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', command,
+    ], {
+      windowsHide: true,
+      shell: false,
+      encoding: 'utf8',
+      timeout: 10_000,
+      maxBuffer: 256_000,
+      env: { ...env, ...extraEnv },
+    })
+    const output = stdout.trim().replace(/^\uFEFF/, '')
+    return output ? JSON.parse(output) : null
+  } catch {
+    return null
+  }
+}
+
+async function uninstallRecords(env) {
+  const paths = REGISTRY_PATHS.map(path => `'${path}'`).join(',')
+  const script = `$records = @(Get-ItemProperty -Path @(${paths}) -ErrorAction SilentlyContinue |
+    Where-Object { [string]$_.DisplayName -match '^ZCode(?:\\s|$)' } |
+    ForEach-Object { [pscustomobject]@{
+      displayName = [string]$_.DisplayName
+      displayVersion = [string]$_.DisplayVersion
+      installLocation = [string]$_.InstallLocation
+      displayIcon = [string]$_.DisplayIcon
+      uninstallString = [string]$_.UninstallString
+    } }); ConvertTo-Json -InputObject $records -Compress -Depth 3`
+  const value = await powershellJson(script, env)
+  return Array.isArray(value) ? value : value ? [value] : []
+}
+
+function rootFromCommand(value) {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  const quoted = /^"([^"]+)"/.exec(trimmed)
+  const executable = quoted?.[1] ?? /^(.+?\.(?:exe|ico))(?=,|\s|$)/i.exec(trimmed)?.[1]
+  return executable && win32.isAbsolute(executable) ? dirname(executable) : null
+}
+
+function candidateRoots(env, records) {
+  const candidates = []
+  const add = (path, source, registryVersion = null) => {
+    if (typeof path !== 'string' || !path.trim()) return
+    candidates.push({ path: path.trim().replace(/^"|"$/g, ''), source, registryVersion })
+  }
+  add(env[ZCODE_INSTALL_ENV_VAR], 'operator-env')
+  for (const record of records) {
+    const version = String(record.displayVersion || '') || null
+    add(record.installLocation, 'uninstall-registry', version)
+    add(rootFromCommand(record.displayIcon), 'uninstall-registry', version)
+    add(rootFromCommand(record.uninstallString), 'uninstall-registry', version)
+  }
+  for (const parent of [env.LOCALAPPDATA, env.ProgramFiles, env['ProgramFiles(x86)'], env.ProgramW6432]) {
+    if (typeof parent !== 'string' || !win32.isAbsolute(parent)) continue
+    add(join(parent, 'Programs', 'ZCode'), 'standard-directory')
+    add(join(parent, 'ZCode'), 'standard-directory')
+  }
+  return candidates
+}
+
+function isWithin(root, child) {
+  const part = relative(root, child)
+  return part !== '' && part !== '..' && !part.startsWith(`..${sep}`) && !isAbsolute(part)
+}
+
+function localWindowsPath(path) {
+  if (typeof path !== 'string' || path.includes('\0')) return false
+  const local = path.startsWith('\\\\?\\') ? path.slice(4) : path
+  return /^[A-Za-z]:[\\/]/.test(local)
+}
+
+async function verifiedCliEntry(path) {
+  if ((await stat(path)).size !== ZCODE_CLI_SIZE) return false
+  const digest = createHash('sha256')
+  for await (const chunk of createReadStream(path)) digest.update(chunk)
+  return digest.digest('hex').toUpperCase() === ZCODE_CLI_SHA256
+}
+
+async function signedExecutable(executable, env) {
+  const script = `$s = Get-AuthenticodeSignature -LiteralPath $env:MODEL_ROUTER_ZCODE_VERIFY_PATH;
+    $v = (Get-Item -LiteralPath $env:MODEL_ROUTER_ZCODE_VERIFY_PATH).VersionInfo;
+    [pscustomobject]@{
+      signatureStatus = [string]$s.Status
+      signerSubject = [string]$s.SignerCertificate.Subject
+      productVersion = [string]$v.ProductVersion
+      fileVersion = [string]$v.FileVersion
+    } | ConvertTo-Json -Compress`
+  const value = await powershellJson(script, env, { MODEL_ROUTER_ZCODE_VERIFY_PATH: executable })
+  if (!value || value.signatureStatus !== 'Valid'
+    || typeof value.signerSubject !== 'string'
+    || !value.signerSubject.includes(ZCODE_SIGNER)) return null
+  const buildVersion = String(value.productVersion || value.fileVersion || '')
+  if (!new RegExp(`^${ZCODE_SUPPORTED_VERSION.replaceAll('.', '\\.')}(?:\\.|$)`).test(buildVersion)) return null
+  return { buildVersion, fileVersion: String(value.fileVersion || ''), publisher: value.signerSubject }
+}
+
+async function checkedBundle(candidate, env) {
+  const input = candidate.path
+  if (!localWindowsPath(input)) return null
+  try {
+    const initial = input.toLowerCase().endsWith('\\zcode.exe') ? dirname(input) : input
+    const root = await realpath(initial)
+    if (!localWindowsPath(root) || !(await stat(root)).isDirectory()) return null
+    const executable = await realpath(join(root, 'ZCode.exe'))
+    const cliEntry = await realpath(join(root, 'resources', 'glm', 'zcode.cjs'))
+    if (!isWithin(root, executable) || !isWithin(root, cliEntry)
+      || !(await stat(executable)).isFile() || !(await stat(cliEntry)).isFile()) return null
+    const signature = await signedExecutable(executable, env)
+    if (!signature || !(await verifiedCliEntry(cliEntry))) return null
+    return Object.freeze({
+      id: 'zcode',
+      version: ZCODE_SUPPORTED_VERSION,
+      buildVersion: signature.buildVersion,
+      fileVersion: signature.fileVersion,
+      registryVersion: candidate.registryVersion,
+      root,
+      executable,
+      cliEntry,
+      cliSha256: ZCODE_CLI_SHA256,
+      publisher: signature.publisher,
+      signatureStatus: 'Valid',
+      source: candidate.source,
+    })
+  } catch {
+    return null
+  }
+}
+
+/** Return the first verified local 3.14.3 bundle, or null when none is usable. */
+export async function discoverZCodeBundle({ env = process.env } = {}) {
+  if (process.platform !== 'win32') return null
+  const records = await uninstallRecords(env)
+  const seen = new Set()
+  for (const candidate of candidateRoots(env, records)) {
+    const key = win32.normalize(candidate.path).toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    const bundle = await checkedBundle(candidate, env)
+    if (bundle) return bundle
+  }
+  return null
+}
+
+/**
+ * ZCode entries in the uninstall registry that did not pass verification, e.g. a
+ * newer release the plugin has not pinned yet. Only used to explain why the
+ * tool shows as unavailable; nothing found here is ever executed.
+ */
+export async function unverifiedZCodeInstalls({ env = process.env } = {}) {
+  if (process.platform !== 'win32') return []
+  const records = await uninstallRecords(env)
+  return records.map(record => ({
+    version: String(record.displayVersion || '') || null,
+    root: [record.installLocation, rootFromCommand(record.displayIcon), rootFromCommand(record.uninstallString)]
+      .find(value => typeof value === 'string' && value.trim()) ?? null,
+  }))
+}