dsh-redteam-memory 0.4.0

package/lib/parts/client.head.js

@@ -0,0 +1,15 @@
+// 常驻（静态）客户端半边 —— 浏览器 bundle 形态（由 tools/build-lib.mjs 生成）。
+//
+// client-modules 是 CJS 懒执行模型：bundle 只【注册】工厂，副作用留在闭包内，
+// 首次 require 时物化。因此这里用 window.__ModuleLoader__.load({id, factory}) 注册。
+//
+// 包装刻意保持极薄（只做作用域与导出），全部改造集中在主体自己的 applyClient 里，
+// 见 lib/parts/client.shim.js。
+window.__ModuleLoader__.load({
+  id: '__PKG_NAME__',
+  factory: (require) => {
+    let React = require('react');
+    var module = { exports: {} };
+    var exports = module.exports;
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+

package/lib/parts/client.shim.js

@@ -0,0 +1,45 @@
+function applyClient(ctx) {
+  // ── 静态形态垫片（动态半边的闭包符号在静态包里不存在）──
+  //
+  // 1) host.call：转到宿主 HTTP 路由（见 lib/host.js 的 __ROUTE_BASE__/rpc）。
+  //    选 HTTP 而非 ctx.remote：Remote 需 typert 代码生成（zod schema + 生成绑定），
+  //    而本插件有 20 个无类型 JSON 句柄，为此引入整套生成链不划算；
+  //    且 fetch 只被【动态】半边屏蔽，静态模块可直接用。
+  // 2) styles.insert：动态 runner 把它作为闭包参数注入，静态 bundle 里没有，
+  //    故自行插入 <style> 元素（浏览器全局可用），并登记到 fiber 便于卸载清理。
+  // 路径必须由生成器按包名填充（__ROUTE_BASE__）。这里曾经写死成
+  // `/dsh-redteam-asset-graph/rpc` —— 那是从资产图谱早期版本复制骨架时带过来的缺陷：
+  // 本插件的面板会去打资产图谱的路由，请求全 404，两者同时安装还会读到对方的数据
+  // （资产图谱 README 记的那次事故是同一个根因）。测试里钉住了实际请求的 url。
+  const RPC_PATH = '__ROUTE_BASE__/rpc'
+  const host = {
+    call(method, args) {
+      return fetch(RPC_PATH, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ method: method, args: args === undefined ? null : args }),
+      }).then(function (res) {
+        return res.json().catch(function () { return null }).then(function (payload) {
+          if (!res.ok || !payload || payload.ok !== true) {
+            const detail = (payload && payload.error) || ('HTTP ' + res.status)
+            throw new Error('__PLUGIN_NAME__ rpc ' + method + ' 失败：' + detail)
+          }
+          return payload.result
+        })
+      })
+    },
+  }
+
+  const STYLE_ID = '__PLUGIN_NAME__-styles'
+  const styles = {
+    insert(css) {
+      if (typeof document === 'undefined') return function () {}
+      let el = document.getElementById(STYLE_ID)
+      if (!el) { el = document.createElement('style'); el.id = STYLE_ID; document.head.appendChild(el) }
+      el.textContent += String(css) + '\n'
+      const dispose = function () { if (el && el.parentNode) el.parentNode.removeChild(el) }
+      try { ctx.effect(function () { return dispose }, '__PLUGIN_NAME__: styles') } catch (e) { return dispose }
+      return dispose
+    },
+  }
+

package/lib/parts/client.tail.js

@@ -0,0 +1,5 @@
+    exports.inject = ['slots', 'timer']
+    exports.apply = function (ctx) { return applyClient(ctx) }
+    return module.exports
+  }
+});

package/lib/parts/host.head.js

@@ -0,0 +1,80 @@
+// 常驻（静态）Host 半边。
+//
+// 主体逻辑与 src/host.js 完全一致（未改一行），差异只在于动态半边的三个符号
+// （harness.defineTool / harness.registerTool / harness.handle）在静态包里不存在，
+// 因此这里提供一个薄垫片 harness：
+//
+//   defineTool / registerTool -> @deepseek-ai/dsh-tools 的 defineTool + ctx.tools.register
+//   handle                    -> 收进 handlers 表，供宿主 HTTP 路由转发（见 rpcRoute）
+//
+// 这样做的理由：机械改写上千行主体逻辑的风险远高于加一层适配，
+// 而且适配层把「动态 ↔ 静态」的差异集中在一个地方，便于日后核对。
+//
+// ── defineTool 的入参形态差异（实测踩坑，务必保留转换）────────────────────────
+// 动态半边的 harness.defineTool 由 dsh-cordis-host-runner 的 guard 提供，它按
+// 「JSON Schema」接受 parameters（{ type:'object', properties, required }）。
+// 静态包的 defineTool 来自 @deepseek-ai/dsh-tools，它要的是 ParameterSchemaSpec：
+// 一个**扁平的属性表**，必填写成每个属性上的 required: true，且根对象没有 type 字段。
+// 直接把 JSON Schema 喂给静态 defineTool 会抛
+//   JsonSchemaError: unsupported JSON schema: parameters.type must be a value schema object
+// —— 工具会在 apply 时全部注册失败。
+// 所以这里做一次转换，src/ 保持动态形态不变。
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+// JSON Schema 属性节点 -> ParameterSchemaSpec 属性节点。只带上工具真的用到的键，
+// 不搬运 pattern / format 之类静态编译器不接受的约束。
+function toPropertySpec(node) {
+  if (!node || typeof node !== 'object') return { type: 'string' }
+  const annotations = {}
+  if (typeof node.description === 'string') annotations.description = node.description
+  if (node.default !== undefined) annotations.default = node.default
+  if (Array.isArray(node.examples)) annotations.examples = node.examples
+  const t = node.type
+  if (t === 'array') {
+    const spec = { type: 'array', items: toPropertySpec(node.items), ...annotations }
+    if (typeof node.minItems === 'number') spec.minItems = node.minItems
+    if (typeof node.maxItems === 'number') spec.maxItems = node.maxItems
+    return spec
+  }
+  if (t === 'object') {
+    return { type: 'object', additionalProperties: node.additionalProperties === false ? false : true, properties: toPropertyMap(node.properties), ...annotations }
+  }
+  const spec = { type: t || 'string', ...annotations }
+  if (Array.isArray(node.enum)) spec.enum = node.enum.slice()
+  if (node.const !== undefined) spec.const = node.const
+  return spec
+}
+
+function toPropertyMap(props) {
+  const out = {}
+  if (props && typeof props === 'object') for (const key of Object.keys(props)) out[key] = toPropertySpec(props[key])
+  return out
+}
+
+// 接受动态形态的 parameters；已是扁平属性表时原样返回（幂等，便于两种写法共存）。
+function toParameterSpec(parameters, required) {
+  if (!parameters || typeof parameters !== 'object') return { type: 'object', properties: {}, additionalProperties: false }
+  let props = parameters.properties
+  if (props === undefined && parameters.type !== 'object') props = parameters
+  const map = toPropertyMap(props)
+  const req = Array.isArray(required) ? required : (Array.isArray(parameters.required) ? parameters.required : [])
+  for (const name of req) if (map[name] && typeof map[name] === 'object') map[name].required = true
+  return map
+}
+
+// 工具定义里除了 parameters 之外都与静态 defineTool 兼容，只替换这一个字段。
+function toStaticToolDefinition(definition) {
+  const rest = {}
+  for (const key of Object.keys(definition)) if (key !== 'parameters') rest[key] = definition[key]
+  rest.parameters = toParameterSpec(definition.parameters, definition.required)
+  return rest
+}
+
+function applyHost(ctx) {
+  const handlers = Object.create(null)
+  const harness = {
+    defineTool(definition) { return defineTool(toStaticToolDefinition(definition)) },
+    registerTool(c, tool) { return c.tools.register(tool) },
+    handle(method, handler) { handlers[method] = handler; return () => { delete handlers[method] } },
+  }
+

package/lib/parts/host.tail.js

@@ -0,0 +1,37 @@
+
+  // 插件自己的 JSON-RPC 端点。
+  // 客户端 bundle 用 fetch 调它（静态模块可用 fetch；动态半边才被屏蔽）。
+  // 全部挂在 __ROUTE_BASE__ 命名空间下，避免与其它插件的路由相撞。
+  const RPC_PATH = '__ROUTE_BASE__/rpc'
+
+  // 把 20 个动态 RPC 句柄经宿主 HTTP 路由暴露给客户端半边。
+  // 客户端是普通模块，可以直接 fetch（动态半边才有 fetch 屏蔽）。
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: RPC_PATH,
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { res.statusCode = 405; res.end(); return }
+      let body = ''
+      try { for await (const chunk of req) body += chunk } catch (e) {}
+      let payload = null
+      try { payload = JSON.parse(body || '{}') } catch (e) {}
+      const method = payload && typeof payload.method === 'string' ? payload.method : ''
+      const fn = handlers[method]
+      res.setHeader('content-type', 'application/json; charset=utf-8')
+      if (!fn) { res.statusCode = 404; res.end(JSON.stringify({ error: 'unknown method: ' + method })); return }
+      try {
+        const result = await fn(payload.args === undefined ? null : payload.args)
+        res.statusCode = 200
+        res.end(JSON.stringify({ ok: true, result: result === undefined ? null : result }))
+      } catch (e) {
+        res.statusCode = 500
+        res.end(JSON.stringify({ ok: false, error: String((e && e.message) || e) }))
+      }
+    },
+  }), 'rtasset: host rpc route')
+}
+
+export const name = '__PLUGIN_NAME__'
+// 三个工具注册进宿主 tools 注册表；这里声明本半边硬依赖的服务。
+export const inject = ['fs', 'shell', 'timer', 'webServer', 'tools']
+export { applyHost as apply }

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "dsh-redteam-memory",
+  "version": "0.4.0",
+  "description": "DSH 红队记忆：本地知识库、Milvus 向量检索与 MinIO，提供统一红队设置页",
+  "license": "MIT",
+  "author": "fasthei",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Fasthei/DSHairedPlugin.git",
+    "directory": "packages/memory"
+  },
+  "keywords": [
+    "dsh",
+    "cordis",
+    "plugin",
+    "redteam",
+    "memory",
+    "context"
+  ],
+  "type": "module",
+  "main": "lib/host.js",
+  "exports": {
+    ".": {
+      "default": "./lib/host.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "tools",
+    "cordis.patch.yml",
+    "LICENSE",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
+    },
+    "dynamic": {
+      "hostHalf": "src/host.js",
+      "clientHalf": "src/client.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "*"
+  },
+  "scripts": {
+    "build:lib": "node tools/build-lib.mjs",
+    "check:lib": "node tools/build-lib.mjs --check",
+    "prepack": "node tools/build-lib.mjs --check",
+    "publish:gh": "node tools/prepare-gh-packages.mjs",
+    "test": "node test/memory-flow.mjs && node test/render-smoke.mjs",
+    "test:flow": "node test/memory-flow.mjs",
+    "test:render": "node test/render-smoke.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}