@twinsearth/fang-dsh-plugin 0.0.0-stage → 3.3.5

package/tools/mcp/server.mjs

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// v3.0.8 MCP stdio server: JSON-RPC 2.0, 8 default tools + opId polling.
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { TOOLS, OpStore, listTools } from './tools.mjs'
+
+const META_TOOLS = [
+  { name: 'get_op', description: '轮询长任务 opId（不假取消）', inputSchema: { type: 'object', properties: { opId: { type: 'string' } }, required: ['opId'] } },
+  { name: 'abandon_op', description: '放弃轮询；不宣称已停止服务端任务', inputSchema: { type: 'object', properties: { opId: { type: 'string' } }, required: ['opId'] } },
+]
+
+export function createHandlers({ callTool, clock = Date.now } = {}) {
+  const ops = new OpStore({ clock })
+  const defs = [...listTools(), ...META_TOOLS]
+  const names = new Set(defs.map((tool) => tool.name))
+  const call = async (name, args = {}) => {
+    if (name === 'get_op') return ops.get(args.opId)
+    if (name === 'abandon_op') return ops.abandon(args.opId)
+    if (!names.has(name)) throw new Error('tool-not-found: ' + name)
+    const spec = TOOLS.find((tool) => tool.name === name)
+    if (spec?.kind === 'op') return ops.start(name, args, () => callTool(name, args))
+    return callTool(name, args)
+  }
+  return { defs, call }
+}
+
+export function createServer({ callTool } = {}) {
+  const handlers = createHandlers({ callTool })
+  return async function handleRequest(request) {
+    const { id = null, method, params } = request || {}
+    const reply = (result) => ({ jsonrpc: '2.0', id, result })
+    const fail = (code, message) => ({ jsonrpc: '2.0', id, error: { code, message } })
+    try {
+      if (method === 'initialize') {
+        return reply({
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'dsh-fang', version: '3.0.8' },
+        })
+      }
+      if (method === 'ping') return reply({})
+      if (method === 'tools/list') {
+        return reply({ tools: handlers.defs.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) })
+      }
+      if (method === 'tools/call') {
+        const name = String(params?.name || '')
+        const result = await handlers.call(name, params?.arguments || {})
+        return reply({ content: [{ type: 'text', text: JSON.stringify(result) }], isError: Boolean(result && result.ok === false) })
+      }
+      return fail(-32601, 'method not found: ' + method)
+    } catch (error) {
+      return fail(-32603, String(error?.message ?? error))
+    }
+  }
+}
+
+const SENSITIVE_KEYS = new Set(['token', 'authtoken', 'datadir', 'clipath', 'template', 'password', 'secret', 'cookie'])
+
+function sanitize(value) {
+  if (Array.isArray(value)) return value.map(sanitize)
+  if (!value || typeof value !== 'object') return value
+  const out = {}
+  for (const [key, child] of Object.entries(value)) {
+    if (SENSITIVE_KEYS.has(String(key).toLowerCase())) continue
+    out[key] = sanitize(child)
+  }
+  return out
+}
+
+export function createHttpCallTool({ baseUrl, token, fetchImpl = fetch }) {
+  const base = String(baseUrl || '').replace(/\/+$/, '')
+  const route = {
+    status: ['GET', '/fang/api/status'],
+    tasks: ['GET', '/fang/api/tasks'],
+    task_status: ['GET', '/fang/api/tasks/status'],
+    essence_list: ['GET', '/fang/api/essence/list'],
+    upgrade_status: ['GET', '/fang/api/upgrade/status'],
+    compat: ['GET', '/fang/api/compat'],
+    derive: ['POST', '/fang/api/derive'],
+    archive: ['POST', '/fang/api/tasks/archive'],
+  }
+  return async function callTool(name, args = {}) {
+    const entry = route[name]
+    if (!entry) throw new Error('tool-not-configured: ' + name)
+    const [method, routePath] = entry
+    let url = base + routePath
+    if (name === 'task_status') url += '?taskId=' + encodeURIComponent(String(args.taskId || ''))
+    const headers = { accept: 'application/json' }
+    if (token) headers['x-fang-auth'] = token
+    const init = { method, headers }
+    if (method === 'POST') {
+      headers['content-type'] = 'application/json'
+      init.body = JSON.stringify(args)
+    }
+    const response = await fetchImpl(url, init)
+    const body = await response.json().catch(() => ({}))
+    return { ok: response.ok && body.ok !== false, status: response.status, body: sanitize(body) }
+  }
+}
+
+async function main() {
+  const readline = await import('node:readline')
+  const baseUrl = process.env.FANG_URL || process.env.FANG_UPSTREAM || 'http://127.0.0.1:61758'
+  const token = process.env.FANG_TOKEN || process.env.DSH_FANG_AUTH_TOKEN || ''
+  const handle = createServer({ callTool: createHttpCallTool({ baseUrl, token }) })
+  const rl = readline.createInterface({ input: process.stdin })
+  rl.on('line', async (line) => {
+    if (!line.trim()) return
+    let request
+    try { request = JSON.parse(line) } catch {
+      process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } }) + '\n')
+      return
+    }
+    const response = await handle(request)
+    if (response) process.stdout.write(JSON.stringify(response) + '\n')
+  })
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  main().catch((error) => { console.error(error); process.exit(1) })
+}

package/tools/mcp/tools.mjs

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// v3.0.8 MCP tool registry: 8 default tools, 4 high-risk hidden, opId idempotency, no fake cancel.
+import crypto from 'node:crypto'
+
+export const HIGH_RISK_TOOLS = Object.freeze(['promote', 'delete', 'restart', 'mirror_upgrade'])
+
+export const TOOLS = Object.freeze([
+  { name: 'status', description: '母体/宿主状态（只读）', kind: 'sync', inputSchema: { type: 'object', properties: {} } },
+  { name: 'tasks', description: '分身任务列表（只读）', kind: 'sync', inputSchema: { type: 'object', properties: {} } },
+  { name: 'task_status', description: '单个分身任务状态（只读）', kind: 'sync', inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, required: ['taskId'] } },
+  { name: 'derive', description: '派生新分身', kind: 'op', inputSchema: { type: 'object', properties: { title: { type: 'string' } } } },
+  { name: 'archive', description: '归档分身（保留 home）', kind: 'op', inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, required: ['taskId'] } },
+  { name: 'essence_list', description: '元主/原身列表（只读）', kind: 'sync', inputSchema: { type: 'object', properties: {} } },
+  { name: 'upgrade_status', description: '升级状态（只读）', kind: 'sync', inputSchema: { type: 'object', properties: {} } },
+  { name: 'compat', description: 'compat 门禁状态（只读）', kind: 'sync', inputSchema: { type: 'object', properties: {} } },
+  ...HIGH_RISK_TOOLS.map((name) => ({
+    name, description: '高风险工具（默认不暴露）', kind: 'op', highRisk: true,
+    inputSchema: { type: 'object', properties: {} },
+  })),
+])
+
+export function listTools({ includeHighRisk = false } = {}) {
+  return TOOLS.filter((tool) => includeHighRisk || !tool.highRisk)
+}
+
+export class OpStore {
+  constructor({ clock = Date.now, timeoutMs = 120_000 } = {}) {
+    this.clock = clock
+    this.timeoutMs = timeoutMs
+    this.ops = new Map()
+    this.keys = new Map()
+  }
+
+  start(name, args = {}, run) {
+    const key = args.idempotencyKey ? `${name}:${args.idempotencyKey}` : ''
+    if (key && this.keys.has(key)) return { ok: true, opId: this.keys.get(key), deduped: true }
+    const opId = 'op_' + crypto.randomBytes(8).toString('hex')
+    this.ops.set(opId, { opId, name, state: 'running', abandoned: false, startedAt: this.clock(), result: null, error: null })
+    if (key) this.keys.set(key, opId)
+    Promise.resolve().then(run).then((result) => {
+      const op = this.ops.get(opId)
+      if (!op || op.state !== 'running') return
+      op.state = 'completed'; op.result = result ?? null
+    }).catch((error) => {
+      const op = this.ops.get(opId)
+      if (!op || op.state !== 'running') return
+      op.state = 'failed'; op.error = String(error?.message ?? error)
+    })
+    return { ok: true, opId, deduped: false }
+  }
+
+  get(opId) {
+    const op = this.ops.get(String(opId))
+    if (!op) return { ok: false, error: 'op-not-found' }
+    if (op.state === 'running' && this.clock() - op.startedAt > this.timeoutMs) op.state = 'timeout'
+    return { ok: true, opId: op.opId, name: op.name, state: op.state, abandoned: op.abandoned, result: op.result, error: op.error }
+  }
+
+  abandon(opId) {
+    const op = this.ops.get(String(opId))
+    if (!op) return { ok: false, error: 'op-not-found' }
+    op.abandoned = true
+    return { ok: true, opId: op.opId, state: op.state, abandoned: true }
+  }
+}

package/tools/recover-queue.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// tools/recover-queue.mjs — 从瓮城的 composer journal 里找回草稿与排队消息。
+//
+// 用法：
+//   node tools/recover-queue.mjs                      # 扫描默认目录，列出可恢复内容
+//   node tools/recover-queue.mjs --data-dir <dir>     # 指定 fang dataDir（可多次）
+//   node tools/recover-queue.mjs --scan-all           # 扫描 ~/.dsh/fang 下所有 dataDir
+//   node tools/recover-queue.mjs --json               # 输出 JSON（便于脚本处理）
+//   node tools/recover-queue.mjs --restore <url> --token <token> --session <sessionId> --index <n>
+//        把第 n 条快照（默认最新）的队列写回官方队列：POST <url>/fang/api/composer/queue
+//   --dry-run  与 --restore 搭配，只打印将要发送的内容
+//
+// 设计原则：只读扫描 + 显式恢复；默认不发送任何消息。
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const args = process.argv.slice(2)
+const readFlag = (name) => {
+  const index = args.indexOf(name)
+  return index >= 0 ? String(args[index + 1] ?? '') : ''
+}
+const has = (name) => args.includes(name)
+
+const jsonOut = has('--json')
+const scanAll = has('--scan-all')
+const dryRun = has('--dry-run')
+const dataDirs = []
+for (let i = 0; i < args.length; i += 1) if (args[i] === '--data-dir' && args[i + 1]) dataDirs.push(args[i + 1])
+if (scanAll || dataDirs.length === 0) {
+  const roots = [path.join(os.homedir(), '.dsh', 'fang')]
+  for (const root of roots) {
+    try {
+      for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue
+        const candidate = path.join(root, entry.name)
+        // fang dataDir 里应有 endpoint.json / audit.jsonl / composer-journal.json 之一
+        const markers = ['composer-journal.json', 'composer-journal-history.jsonl', 'audit.jsonl', 'endpoint.json']
+        if (markers.some((marker) => fs.existsSync(path.join(candidate, marker)))) dataDirs.push(candidate)
+      }
+    } catch { /* 没有 fang 目录 */ }
+  }
+}
+
+const readJson = (file) => {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch { return null }
+}
+const readLines = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((line) => {
+      try { return JSON.parse(line) } catch { return null }
+    }).filter(Boolean)
+  } catch { return [] }
+}
+
+const report = []
+for (const dir of dataDirs) {
+  const journalFile = path.join(dir, 'composer-journal.json')
+  const historyFile = path.join(dir, 'composer-journal-history.jsonl')
+  const journal = readJson(journalFile)
+  const entries = []
+  if (journal && typeof journal === 'object') {
+    for (const [key, entry] of Object.entries(journal)) {
+      const queue = Array.isArray(entry?.queue) ? entry.queue : []
+      if (!entry?.draft && queue.length === 0) continue
+      entries.push({ key, draft: String(entry?.draft || ''), queue, updatedAt: entry?.updatedAt || '', source: 'journal' })
+    }
+  }
+  for (const snapshot of readLines(historyFile)) {
+    const queue = Array.isArray(snapshot?.queue) ? snapshot.queue : []
+    if (queue.length === 0) continue
+    entries.push({
+      key: String(snapshot?.key || ''),
+      draft: String(snapshot?.draft || ''),
+      queue,
+      updatedAt: String(snapshot?.updatedAt || ''),
+      sessionKey: String(snapshot?.sessionKey || ''),
+      source: 'history',
+    })
+  }
+  entries.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+  report.push({ dataDir: dir, journalFile, historyFile, entries })
+}
+
+const restoreUrl = readFlag('--restore').replace(/\/+$/, '')
+const restoreToken = readFlag('--token') || String(process.env.FANG_TOKEN ?? '')
+const restoreSession = readFlag('--session')
+const indexFlag = Number(readFlag('--index') || 0)
+
+if (!jsonOut) {
+  console.log(`扫描目录 ${dataDirs.length} 个`)
+  for (const item of report) {
+    console.log(`\n=== ${item.dataDir}`)
+    console.log(`  journal: ${fs.existsSync(item.journalFile) ? item.journalFile : '(none)'}`)
+    console.log(`  history: ${fs.existsSync(item.historyFile) ? item.historyFile : '(none)'}`)
+    if (item.entries.length === 0) { console.log('  可恢复条目: 0'); continue }
+    item.entries.forEach((entry, index) => {
+      console.log(`  [${index}] ${entry.source} · key=${JSON.stringify(entry.key)} · ${entry.updatedAt} · queue=${entry.queue.length}${entry.draft ? ' · draft=' + JSON.stringify(entry.draft.slice(0, 40)) : ''}`)
+      for (const queueItem of entry.queue.slice(0, 6)) {
+        const text = String(queueItem?.text ?? '')
+        const broken = /\?{3,}/.test(text)
+        console.log(`        • ${JSON.stringify(text.slice(0, 120))}${broken ? '   ⚠ 疑似乱码（原文已丢失）' : ''}`)
+      }
+    })
+  }
+}
+
+if (jsonOut) {
+  console.log(JSON.stringify({ at: new Date().toISOString(), dataDirs, report }, null, 2))
+  if (!restoreUrl) process.exit(0)
+}
+
+if (restoreUrl) {
+  const flattened = report.flatMap((item) => item.entries.map((entry) => ({ ...entry, dataDir: item.dataDir })))
+  const target = flattened[indexFlag]
+  if (!target) { console.error(`没有第 ${indexFlag} 条可恢复记录（共 ${flattened.length} 条）`); process.exit(1) }
+  if (!restoreSession) { console.error('恢复需要 --session <sessionId>（官方队列按会话恢复）'); process.exit(1) }
+  const items = target.queue.map((queueItem) => ({ text: String(queueItem?.text ?? '').slice(0, 4000) })).filter((item) => item.text.trim())
+  if (items.length === 0) { console.error('该快照没有可恢复的队列内容'); process.exit(1) }
+  const payload = { sessionId: restoreSession, items }
+  console.log(`\n准备恢复 ${items.length} 条 → ${restoreUrl}/fang/api/composer/queue（session=${restoreSession}）`)
+  if (dryRun) { console.log('--dry-run：未发送'); process.exit(0) }
+  if (!restoreToken) { console.error('恢复需要 --token 或环境变量 FANG_TOKEN'); process.exit(1) }
+  const res = await fetch(`${restoreUrl}/fang/api/composer/queue`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'x-fang-auth': restoreToken },
+    body: JSON.stringify(payload),
+  })
+  const text = await res.text()
+  console.log(`HTTP ${res.status} ${text.slice(0, 200)}`)
+  process.exit(res.ok ? 0 : 1)
+}