jiema-workbuddy-mcp 0.1.9 → 0.1.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +8 -12
- package/lib/client.mjs +17 -1
- package/lib/contract.mjs +97 -0
- package/lib/credentials.mjs +135 -6
- package/lib/jsonFiles.mjs +4 -0
- package/lib/previewStore.mjs +28 -47
- package/lib/tools.mjs +128 -68
- package/package.json +2 -2
- package/lib/generated/designCompiler.manifest.json +0 -91
- package/lib/generated/designCompiler.mjs +0 -202
- package/lib/preflightSchema.mjs +0 -30
package/README.md
CHANGED
|
@@ -1,5 +1,9 @@
|
|
|
1
1
|
# 捷码 WorkBuddy MCP Server
|
|
2
2
|
|
|
3
|
+
0.1.14使用协议1,配套技能3.10.5。WorkBuddy 宿主可将本包作为 stdio MCP 服务托管;技能随包提供同一份 mcpServers 配置,由模型交给 WorkBuddy 原生配置入口;宿主负责 Node/npm、服务进程及工具加载,macOS 和 Windows 使用相同声明。保留27个工具;SQL与已有项目配置使用正式预览和保存合同。npm发布以公共 registry 回读为准,市场连接器与独立技能各自验收。
|
|
4
|
+
|
|
5
|
+
SQL的正式手工决策新增SET_PROJECT_CONFIGURATION和SET_ENTITY_PRESENTATION;评论、游客读取和字段类型复用生成器规则。PUBLIC_CLIENT登录不自动注册,公开内容不扩大角色权限。WorkBuddy仍不调用站内AI或接受ACCEPT_AI_SELECTION。来源和计费边界保持不变。
|
|
6
|
+
|
|
3
7
|
这是 WorkBuddy 的本地 MCP 工具服务。WorkBuddy 连接后直接调用结构化工具;用户和模型无需安装或执行捷码 CLI。模型负责需求语义、字段、关系、权限与规则审查,捷码服务负责参数校验、授权、套餐/积分结算、确定性生成和成果交付。
|
|
4
8
|
|
|
5
9
|
需求与规范结构入口固定使用 `entryMode=manual`、`design.source=manual`;`project_preflight` 和 `project_create` 不接受捷码站内 `ai` 模式,旧 `ai` 预览也不能续跑。SQL 入口只接受显式登录、结构与权限决策,不接受网站 AI 候选采纳或撤销;MCP HTTP 客户端仅允许 WorkBuddy 专属接口和平台目录,不调用捷码内部 AI 优化接口。
|
|
@@ -10,17 +14,9 @@
|
|
|
10
14
|
|
|
11
15
|
## 完整文件输入与输出
|
|
12
16
|
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
`lib/generated/designCompiler.mjs` 和manifest只由 `node workbuddy/connector/scripts/build-design-compiler.mjs` 从正式源码生成,`--check`逐字节检查包和源码hash;技能打包调用该门禁。用户机器无需仓库源码、TS工具链或服务器依赖。未明确login/web/authorization、未知名字或关系引用均拒绝;不猜事实或扩权。
|
|
16
|
-
|
|
17
|
-
0.1.9 同步当前正式编译器:保留实体与字段的业务说明、正式登录凭据说明,以及领域事实的身份映射规则。工具数量、文件传输、冻结预览、请求身份、授权与计费协议保持不变。发布前完成同源检查、编译/传输/恢复回归和安装包字节核验;仅修改本地版本不代表已在npm发布。
|
|
18
|
-
|
|
19
|
-
0.1.6 起,现有 project_preflight、project_sql_preview、project_sql_commit、project_template_use 接受 `inputFile` + `inputSha256`:前者为允许工作区内完整请求 JSON 的绝对路径,后者为原文件字节的 SHA-256。文件内容就是原 HTTP 正文,不含文件参数;SQL 文件不再包 input。与原内联字段互斥,不增工具、不改授权/计费/服务端业务门。预检仍冻结完整正文,创建仍仅用 previewId。
|
|
20
|
-
|
|
21
|
-
文件读取只接受允许工作区内普通 UTF-8 JSON 文件,核对摘要与原接口大小限制。正文不重编号、不省略数组/null/字段、不改业务规则。Read 输出截断是显示问题,不是服务端拒绝;不得靠“压缩设计”解决。
|
|
17
|
+
每次业务请求先获取服务端合同清单,校验规范 JSON 的 SHA-256。每个源站的连接实例按合同与种类缓存完整 Schema 及编译后的 AJV 校验器。进程重启或合同更新时重新取回。清单不可读时保留原件并返回错误。同一协议内使用最新业务合同。最低客户端由服务端清单给出,低于最低版本时宿主更新市场连接器并重载。
|
|
22
18
|
|
|
23
|
-
|
|
19
|
+
需求声明使用服务端的确定性编译器。SQL 的解析器事实由服务端绑定。首次预览登记 requestId,已有任务传原业务 UUID。最终预览返回不可变 previewId。提交按该预览取正文、摘要、签名与请求身份;新项目查询所属账号的原回执,已有项目通过设计版本锁保存并回读。签名过期或相关合同变化时按原请求身份重新预览并审阅。网络超时保留检查点。
|
|
24
20
|
|
|
25
21
|
上述工具与 schema_get/project_show 支持可选 resultFile。文件模式、显式输出路径或大响应将完整 JSON 保存至工作区,返回 output.path/sha256/bytes/complete 及有界摘要;默认内容寻址保存于 .jiema-mcp-results,文件权限0600,已有异内容文件不覆盖。complete仅表示文件完整,不表示业务成功。先解析完整回执,再处理对应状态;大Schema按对象/$defs分页读取。小型内联工具调用保留原返回形状。显式目标冲突在网络请求前拒绝;调用后写入竞态保存备用回执,不让模型重建收费项目。
|
|
26
22
|
|
|
@@ -32,9 +28,9 @@ npm ci
|
|
|
32
28
|
JIEMA_WORKBUDDY_BASE_URL=http://127.0.0.1:3000 node ./bin/server.mjs
|
|
33
29
|
```
|
|
34
30
|
|
|
35
|
-
`JIEMA_WORKBUDDY_BASE_URL` 是 MCP 进程级配置,不由模型通过工具参数修改。正式环境默认 `https://www.jiemaai.com`;HTTP 仅接受回环地址。下载及源码摘要默认仅允许用户主目录下的 `WorkBuddy`,可在 MCP 进程配置 `JIEMA_WORKBUDDY_ALLOWED_ROOTS` 为系统路径分隔符连接的绝对目录列表。macOS 默认将凭据保存在 Keychain
|
|
31
|
+
`JIEMA_WORKBUDDY_BASE_URL` 是 MCP 进程级配置,不由模型通过工具参数修改。正式环境默认 `https://www.jiemaai.com`;HTTP 仅接受回环地址。下载及源码摘要默认仅允许用户主目录下的 `WorkBuddy`,可在 MCP 进程配置 `JIEMA_WORKBUDDY_ALLOWED_ROOTS` 为系统路径分隔符连接的绝对目录列表。macOS 默认将凭据保存在 Keychain;Windows 默认用当前用户 DPAPI 加密后保存在用户配置目录;安全存储不可用时普通宿主托管模式仅保存在当前 MCP 进程内。重启后须用 connect_status 回读实际授权状态。旧明文凭据只有迁移到对应安全存储成功才删除;读取时仅进入会话内存会保留旧副本。`XDG_CONFIG_HOME` 只用于隔离设备码状态与图稿回执;设置 `JIEMA_WORKBUDDY_CREDENTIAL_STORE=session` 会主动关闭系统安全存储,新授权仅对当前 MCP 进程有效。MCP 服务通过设备码向用户申请授权,不向模型输出凭据。
|
|
36
32
|
|
|
37
|
-
Keychain 写入通过 `security -i` 的标准输入传递命令,凭据不进入进程参数或磁盘;写后必须逐字回读一致才返回 `credentialStorage:keychain
|
|
33
|
+
Keychain 写入通过 `security -i` 的标准输入传递命令,凭据不进入进程参数或磁盘;写后必须逐字回读一致才返回 `credentialStorage:keychain`。Windows 通过 PowerShell DPAPI CurrentUser 加解密,明文只经过标准输入/输出和进程内存,不进入参数或磁盘。非终端环境下向 macOS `-w` 直接管道输入会出现退出码成功却存入空串,不能据退出码删除旧副本。macOS 可用 `JIEMA_WORKBUDDY_TEST_KEYCHAIN=1 npm test` 执行真实钥匙串跨进程回归;Windows 真机回归需在 Windows 用户环境执行。
|
|
38
34
|
|
|
39
35
|
本地 WorkBuddy 自定义连接器可在 `mcpServers` 中配置 `type: "stdio"`、`command: "node"`、绝对脚本路径和 Node runtime。用户在 WorkBuddy 内使用技能与 MCP 工具,无需手工运行上面的调试命令。`connector/mcp.json` 使用固定版本的公开 npm 包;发布前须确认该版本在公共 registry 可获取,并验证平台连接与认证流程。发布状态以 npm 回读和 WorkBuddy 开放平台审核回执为准,本机自定义连接器通过不等于市场上架通过。
|
|
40
36
|
|
package/lib/client.mjs
CHANGED
|
@@ -1,3 +1,7 @@
|
|
|
1
|
+
import { readFileSync } from 'node:fs'
|
|
2
|
+
|
|
3
|
+
export const { version: clientVersion } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
|
|
4
|
+
export const protocolVersion = 1
|
|
1
5
|
const DEFAULT_BASE_URL = 'https://www.jiemaai.com'
|
|
2
6
|
|
|
3
7
|
export function resolveBaseUrl(value = process.env.JIEMA_WORKBUDDY_BASE_URL) {
|
|
@@ -21,14 +25,18 @@ export async function apiRequest(baseUrl, path, options = {}) {
|
|
|
21
25
|
const response = await fetch(url, {
|
|
22
26
|
method: options.method || 'GET',
|
|
23
27
|
headers: {
|
|
28
|
+
'x-jiema-workbuddy-client': clientVersion,
|
|
29
|
+
'x-jiema-workbuddy-protocol': String(protocolVersion),
|
|
30
|
+
...(options.contractId ? { 'x-jiema-workbuddy-contract': options.contractId } : {}),
|
|
24
31
|
...(options.body === undefined ? {} : { 'Content-Type': 'application/json' }),
|
|
25
32
|
...(options.credential ? { 'x-jiema-workbuddy-credential': options.credential } : {}),
|
|
26
33
|
},
|
|
27
34
|
...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
|
|
28
35
|
signal: AbortSignal.timeout(options.timeoutMs || 8000),
|
|
29
36
|
cache: 'no-store',
|
|
37
|
+
redirect: 'error',
|
|
30
38
|
})
|
|
31
|
-
if (response.status === 204) return null
|
|
39
|
+
if (response.status === 204 && options.method === 'DELETE') return null
|
|
32
40
|
const payload = await response.json().catch(() => null)
|
|
33
41
|
if (!response.ok) {
|
|
34
42
|
const message = payload && typeof payload.detail === 'string'
|
|
@@ -67,5 +75,13 @@ export async function apiRequest(baseUrl, path, options = {}) {
|
|
|
67
75
|
}
|
|
68
76
|
throw error
|
|
69
77
|
}
|
|
78
|
+
if (options.contractId && response.headers.get('x-jiema-workbuddy-contract') !== options.contractId) {
|
|
79
|
+
throw Object.assign(new Error('响应缺少所请求的合同标识,请按原请求身份核对回执。'), { code: 'WORKBUDDY_RESPONSE_CONTRACT' })
|
|
80
|
+
}
|
|
81
|
+
if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
|
|
82
|
+
throw Object.assign(new Error('未收到完整 JSON 对象。请保留原请求身份并核对回执。'), {
|
|
83
|
+
code: 'WORKBUDDY_RESPONSE_CONTRACT',
|
|
84
|
+
})
|
|
85
|
+
}
|
|
70
86
|
return payload
|
|
71
87
|
}
|
package/lib/contract.mjs
ADDED
|
@@ -0,0 +1,97 @@
|
|
|
1
|
+
import { createHash } from 'node:crypto'
|
|
2
|
+
import Ajv from 'ajv'
|
|
3
|
+
import addFormats from 'ajv-formats'
|
|
4
|
+
import { apiRequest, clientVersion, protocolVersion } from './client.mjs'
|
|
5
|
+
|
|
6
|
+
function canonical(value) {
|
|
7
|
+
if (Array.isArray(value)) return '[' + value.map(canonical).join(',') + ']'
|
|
8
|
+
if (value === null || typeof value !== 'object') return JSON.stringify(value)
|
|
9
|
+
return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key])).join(',') + '}'
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export function digestJson(value) {
|
|
13
|
+
return createHash('sha256').update(canonical(value)).digest('hex')
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
function problem(code, message, data = {}) {
|
|
17
|
+
return Object.assign(new Error(message), { code, responseBody: { code, data } })
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
function older(installed, minimum) {
|
|
21
|
+
const required = minimum.split('.').map(Number)
|
|
22
|
+
return (installed.split('.').map((value, index) => Number(value) - required[index]).find(value => value !== 0) ?? 0) < 0
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export class WorkBuddyContracts {
|
|
26
|
+
#documents = new Map()
|
|
27
|
+
#currentId
|
|
28
|
+
constructor(connection) {
|
|
29
|
+
this.connection = connection
|
|
30
|
+
this.baseUrl = connection.baseUrl
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
async manifest() {
|
|
34
|
+
const value = await apiRequest(this.baseUrl, '/api/workbuddy/schema/contract', { timeoutMs: 20_000 })
|
|
35
|
+
if (!value || !/^[a-f0-9]{64}$/u.test(value.contractId) || !/^\d+\.\d+\.\d+$/u.test(value.minimumClient)) {
|
|
36
|
+
throw problem('WORKBUDDY_CONTRACT_UNAVAILABLE', '无法读取完整的协议清单,请保留检查点并恢复连接。')
|
|
37
|
+
}
|
|
38
|
+
const { contractId, ...content } = value
|
|
39
|
+
if (digestJson(content) !== contractId) throw problem('WORKBUDDY_CONTRACT_DIGEST', '合同清单摘要校验失败。')
|
|
40
|
+
if (content.protocolVersion !== protocolVersion || older(clientVersion, content.minimumClient)) {
|
|
41
|
+
throw problem('WORKBUDDY_CLIENT_UPGRADE_REQUIRED', '请在 WorkBuddy 更新连接器,保留原任务继续。', {
|
|
42
|
+
minimumClient: content.minimumClient, installedClient: clientVersion, executed: false,
|
|
43
|
+
})
|
|
44
|
+
}
|
|
45
|
+
if (contractId !== this.#currentId) {
|
|
46
|
+
this.#documents.clear()
|
|
47
|
+
this.#currentId = contractId
|
|
48
|
+
}
|
|
49
|
+
return value
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
async entry(manifest, kind) {
|
|
53
|
+
const digest = manifest.schemas?.[kind]
|
|
54
|
+
if (!/^[a-f0-9]{64}$/u.test(digest)) throw problem('WORKBUDDY_SCHEMA_UNAVAILABLE', '当前服务未提供请求的正式 Schema。', { kind })
|
|
55
|
+
const key = manifest.contractId + '/' + kind
|
|
56
|
+
const cached = this.#documents.get(key)
|
|
57
|
+
if (cached) return cached
|
|
58
|
+
const published = await apiRequest(this.baseUrl, '/api/workbuddy/schema/' + encodeURIComponent(kind), {
|
|
59
|
+
contractId: manifest.contractId, timeoutMs: 20_000,
|
|
60
|
+
})
|
|
61
|
+
const { contractId, schemaDigest, ...document } = published ?? {}
|
|
62
|
+
if (contractId !== manifest.contractId || digest !== schemaDigest || digest !== digestJson(document) ||
|
|
63
|
+
document.kind !== kind || !document.schema || typeof document.schema !== 'object') {
|
|
64
|
+
throw problem('WORKBUDDY_SCHEMA_DIGEST', '正式 Schema 的标识或摘要不符。', { kind })
|
|
65
|
+
}
|
|
66
|
+
const validator = addFormats(new Ajv({ allErrors: true, strictSchema: true, strictTypes: false, ownProperties: true }))
|
|
67
|
+
const entry = { published, validate: validator.compile(document.schema) }
|
|
68
|
+
if (manifest.contractId === this.#currentId) this.#documents.set(key, entry)
|
|
69
|
+
return entry
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
async run(readOnly, callback) {
|
|
73
|
+
for (let attempt = 0; ; attempt++) {
|
|
74
|
+
try { return await callback(await this.manifest()) }
|
|
75
|
+
catch (error) {
|
|
76
|
+
if (!readOnly || attempt !== 0 || error.code !== 'WORKBUDDY_CONTRACT_CHANGED' || error.responseBody?.data?.executed !== false) throw error
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
schema(kind) {
|
|
82
|
+
return this.run(true, async manifest => kind === 'contract' ? manifest : (await this.entry(manifest, kind)).published)
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
post(path, kind, input, { requestId, previewSeal, readOnly = false, anonymous = false } = {}) {
|
|
86
|
+
return this.run(readOnly, async manifest => {
|
|
87
|
+
const { validate } = await this.entry(manifest, kind)
|
|
88
|
+
if (!validate(input)) throw problem('WORKBUDDY_INPUT_SCHEMA', '请求未通过当前正式合同。', {
|
|
89
|
+
kind, contractId: manifest.contractId, issues: validate.errors, executed: false,
|
|
90
|
+
})
|
|
91
|
+
const options = { method: 'POST', contractId: manifest.contractId, timeoutMs: 35_000,
|
|
92
|
+
body: { protocolVersion, contractId: manifest.contractId, kind, input, requestId, ...(previewSeal ? { previewSeal } : {}) } }
|
|
93
|
+
const value = anonymous ? await apiRequest(this.baseUrl, path, options) : await this.connection.authorizedRequest(path, options)
|
|
94
|
+
return { ...value, contractId: manifest.contractId }
|
|
95
|
+
})
|
|
96
|
+
}
|
|
97
|
+
}
|
package/lib/credentials.mjs
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
|
-
import { createHash } from 'node:crypto'
|
|
1
|
+
import { createHash, randomUUID } from 'node:crypto'
|
|
2
2
|
import { spawn } from 'node:child_process'
|
|
3
|
-
import { readFile, rm } from 'node:fs/promises'
|
|
3
|
+
import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
|
|
4
4
|
import { homedir } from 'node:os'
|
|
5
|
-
import { join } from 'node:path'
|
|
5
|
+
import { dirname, join } from 'node:path'
|
|
6
6
|
|
|
7
7
|
const SERVICE = 'com.jiema.workbuddy.mcp'
|
|
8
8
|
const sessionCredentials = new Map()
|
|
@@ -23,10 +23,18 @@ export function credentialPath(baseUrl) {
|
|
|
23
23
|
return join(configRoot(), `${profile(baseUrl)}.json`)
|
|
24
24
|
}
|
|
25
25
|
|
|
26
|
+
export function protectedCredentialPath(baseUrl) {
|
|
27
|
+
return join(configRoot(), `${profile(baseUrl)}.dpapi`)
|
|
28
|
+
}
|
|
29
|
+
|
|
26
30
|
function useKeychain() {
|
|
27
31
|
return process.platform === 'darwin' && process.env.JIEMA_WORKBUDDY_CREDENTIAL_STORE !== 'session'
|
|
28
32
|
}
|
|
29
33
|
|
|
34
|
+
function useWindowsDpapi() {
|
|
35
|
+
return process.platform === 'win32' && process.env.JIEMA_WORKBUDDY_CREDENTIAL_STORE !== 'session'
|
|
36
|
+
}
|
|
37
|
+
|
|
30
38
|
async function security(args, stdinText) {
|
|
31
39
|
return new Promise((resolve, reject) => {
|
|
32
40
|
const child = spawn('/usr/bin/security', args, { stdio: ['pipe', 'pipe', 'pipe'] })
|
|
@@ -36,6 +44,7 @@ async function security(args, stdinText) {
|
|
|
36
44
|
child.stdout.setEncoding('utf8').on('data', (chunk) => { stdout += chunk })
|
|
37
45
|
child.stderr.setEncoding('utf8').on('data', (chunk) => { stderr += chunk })
|
|
38
46
|
child.on('error', (error) => { clearTimeout(timeout); reject(error) })
|
|
47
|
+
child.stdin.on('error', reject)
|
|
39
48
|
child.on('close', (code) => {
|
|
40
49
|
clearTimeout(timeout)
|
|
41
50
|
if (code === 0) resolve(stdout.trimEnd())
|
|
@@ -45,6 +54,103 @@ async function security(args, stdinText) {
|
|
|
45
54
|
})
|
|
46
55
|
}
|
|
47
56
|
|
|
57
|
+
const POWERSHELL_UTF8 = [
|
|
58
|
+
"$utf8 = New-Object System.Text.UTF8Encoding($false)",
|
|
59
|
+
'[Console]::InputEncoding = $utf8',
|
|
60
|
+
'[Console]::OutputEncoding = $utf8',
|
|
61
|
+
'$OutputEncoding = $utf8',
|
|
62
|
+
]
|
|
63
|
+
|
|
64
|
+
function powershellExecutable(env = process.env) {
|
|
65
|
+
const root = env.SystemRoot || env.WINDIR
|
|
66
|
+
return root ? join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe') : 'powershell.exe'
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
async function runPowerShell(script, input) {
|
|
70
|
+
const source = [...POWERSHELL_UTF8, "$ErrorActionPreference = 'Stop'", script].join('; ')
|
|
71
|
+
const encoded = Buffer.from(source, 'utf16le').toString('base64')
|
|
72
|
+
return new Promise((resolve, reject) => {
|
|
73
|
+
const child = spawn(powershellExecutable(), [
|
|
74
|
+
'-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', encoded,
|
|
75
|
+
], { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true })
|
|
76
|
+
let stdout = ''
|
|
77
|
+
const timeout = setTimeout(() => child.kill(), 10_000)
|
|
78
|
+
child.stdout.setEncoding('utf8').on('data', (chunk) => {
|
|
79
|
+
stdout += chunk
|
|
80
|
+
if (stdout.length > 1024 * 1024) child.kill()
|
|
81
|
+
})
|
|
82
|
+
child.on('error', () => {
|
|
83
|
+
clearTimeout(timeout)
|
|
84
|
+
reject(new Error('Windows 当前用户凭据保护服务启动失败'))
|
|
85
|
+
})
|
|
86
|
+
child.stdin.on('error', () => reject(new Error('Windows 当前用户凭据保护服务输入失败')))
|
|
87
|
+
child.on('close', (code) => {
|
|
88
|
+
clearTimeout(timeout)
|
|
89
|
+
if (code !== 0 || stdout.length > 1024 * 1024) {
|
|
90
|
+
reject(new Error('Windows 当前用户凭据保护服务失败'))
|
|
91
|
+
return
|
|
92
|
+
}
|
|
93
|
+
resolve(stdout)
|
|
94
|
+
})
|
|
95
|
+
child.stdin.end(input)
|
|
96
|
+
})
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
const DPAPI_PROTECT = [
|
|
100
|
+
'$plain = [Console]::In.ReadToEnd()',
|
|
101
|
+
'$secure = ConvertTo-SecureString -String $plain -AsPlainText -Force',
|
|
102
|
+
'[Console]::Out.Write((ConvertFrom-SecureString -SecureString $secure))',
|
|
103
|
+
].join('; ')
|
|
104
|
+
|
|
105
|
+
const DPAPI_UNPROTECT = [
|
|
106
|
+
'$encrypted = [Console]::In.ReadToEnd()',
|
|
107
|
+
'$secure = ConvertTo-SecureString -String $encrypted',
|
|
108
|
+
'$ptr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secure)',
|
|
109
|
+
'try { $plain = [Runtime.InteropServices.Marshal]::PtrToStringBSTR($ptr); [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($plain))) } finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ptr) }',
|
|
110
|
+
].join('; ')
|
|
111
|
+
|
|
112
|
+
// DPAPI CurrentUser:明文只经管道与内存,不进入进程参数或文件。
|
|
113
|
+
export function createWindowsCredentialStore({ filePath, run = runPowerShell }) {
|
|
114
|
+
async function decode(encrypted) {
|
|
115
|
+
try {
|
|
116
|
+
const encoded = (await run(DPAPI_UNPROTECT, encrypted)).trim()
|
|
117
|
+
const bytes = Buffer.from(encoded, 'base64')
|
|
118
|
+
if (!encoded || bytes.toString('base64') !== encoded) throw new Error('invalid')
|
|
119
|
+
return new TextDecoder('utf-8', { fatal: true }).decode(bytes)
|
|
120
|
+
} catch {
|
|
121
|
+
throw new Error('Windows DPAPI 凭据无法解密;已保留原文件,请在原 Windows 用户配置下恢复。')
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
return {
|
|
125
|
+
async read() {
|
|
126
|
+
let encrypted
|
|
127
|
+
try {
|
|
128
|
+
encrypted = (await readFile(filePath, 'utf8')).trim()
|
|
129
|
+
} catch (error) {
|
|
130
|
+
if (error?.code === 'ENOENT') return null
|
|
131
|
+
throw error
|
|
132
|
+
}
|
|
133
|
+
return decode(encrypted)
|
|
134
|
+
},
|
|
135
|
+
async write(credential) {
|
|
136
|
+
const encrypted = (await run(DPAPI_PROTECT, credential)).trim()
|
|
137
|
+
if (!encrypted || await decode(encrypted) !== credential) return false
|
|
138
|
+
await mkdir(dirname(filePath), { recursive: true, mode: 0o700 })
|
|
139
|
+
const temporary = `${filePath}.${randomUUID()}.tmp`
|
|
140
|
+
try {
|
|
141
|
+
await writeFile(temporary, `${encrypted}\n`, { flag: 'wx', mode: 0o600 })
|
|
142
|
+
await rename(temporary, filePath)
|
|
143
|
+
} finally {
|
|
144
|
+
await rm(temporary, { force: true })
|
|
145
|
+
}
|
|
146
|
+
return await this.read() === credential
|
|
147
|
+
},
|
|
148
|
+
async remove() {
|
|
149
|
+
await rm(filePath, { force: true })
|
|
150
|
+
},
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
|
|
48
154
|
function isMissingKeychainItem(error) {
|
|
49
155
|
return error?.code === 44 || /could not be found|指定的项目不存在|找不到指定的项目/iu.test(error?.message ?? '')
|
|
50
156
|
}
|
|
@@ -80,13 +186,21 @@ export async function readCredential(baseUrl) {
|
|
|
80
186
|
if (!isMissingKeychainItem(error)) throw error
|
|
81
187
|
}
|
|
82
188
|
}
|
|
189
|
+
if (useWindowsDpapi()) {
|
|
190
|
+
const store = createWindowsCredentialStore({ filePath: protectedCredentialPath(baseUrl) })
|
|
191
|
+
const stored = await store.read()
|
|
192
|
+
if (stored) {
|
|
193
|
+
sessionCredentials.set(baseUrl, stored)
|
|
194
|
+
return stored
|
|
195
|
+
}
|
|
196
|
+
}
|
|
83
197
|
const legacy = await readLegacyCredential(baseUrl)
|
|
84
198
|
if (!legacy) return null
|
|
85
|
-
//
|
|
199
|
+
// 迁移时先不删旧明文:只有真正落到系统安全存储才删。
|
|
86
200
|
// 会话内存随进程结束消失,若此时删掉磁盘副本,下一次启动就没有任何可用凭据,
|
|
87
201
|
// 表现为“刚连上又掉授权”。
|
|
88
202
|
const storage = await writeCredential(baseUrl, legacy, { dropLegacy: false })
|
|
89
|
-
if (storage === 'keychain') await rm(credentialPath(baseUrl), { force: true })
|
|
203
|
+
if (storage === 'keychain' || storage === 'windows-dpapi') await rm(credentialPath(baseUrl), { force: true })
|
|
90
204
|
return legacy
|
|
91
205
|
}
|
|
92
206
|
|
|
@@ -94,6 +208,18 @@ export async function writeCredential(baseUrl, credential, options = {}) {
|
|
|
94
208
|
const dropLegacy = options.dropLegacy !== false
|
|
95
209
|
sessionCredentials.set(baseUrl, credential)
|
|
96
210
|
if (!useKeychain()) {
|
|
211
|
+
if (useWindowsDpapi()) {
|
|
212
|
+
try {
|
|
213
|
+
const store = createWindowsCredentialStore({ filePath: protectedCredentialPath(baseUrl) })
|
|
214
|
+
if (await store.write(credential)) {
|
|
215
|
+
if (dropLegacy) await rm(credentialPath(baseUrl), { force: true })
|
|
216
|
+
return 'windows-dpapi'
|
|
217
|
+
}
|
|
218
|
+
} catch {
|
|
219
|
+
return 'session'
|
|
220
|
+
}
|
|
221
|
+
return 'session'
|
|
222
|
+
}
|
|
97
223
|
if (dropLegacy) await rm(credentialPath(baseUrl), { force: true })
|
|
98
224
|
return 'session'
|
|
99
225
|
}
|
|
@@ -104,7 +230,9 @@ export async function writeCredential(baseUrl, credential, options = {}) {
|
|
|
104
230
|
.map(quoteSecurityArgument).join(' ')
|
|
105
231
|
await security(['-i'], command)
|
|
106
232
|
const stored = await security(['find-generic-password', '-a', profile(baseUrl), '-s', SERVICE, '-w'])
|
|
107
|
-
if (stored !== credential)
|
|
233
|
+
if (stored !== credential) {
|
|
234
|
+
return 'session'
|
|
235
|
+
}
|
|
108
236
|
} catch {
|
|
109
237
|
// 钥匙串写入失败时只在内存里生效,因此保留磁盘副本,下次启动仍可读取。
|
|
110
238
|
return 'session'
|
|
@@ -116,6 +244,7 @@ export async function writeCredential(baseUrl, credential, options = {}) {
|
|
|
116
244
|
export async function removeCredential(baseUrl) {
|
|
117
245
|
sessionCredentials.delete(baseUrl)
|
|
118
246
|
await rm(credentialPath(baseUrl), { force: true })
|
|
247
|
+
await rm(protectedCredentialPath(baseUrl), { force: true })
|
|
119
248
|
if (!useKeychain()) return
|
|
120
249
|
try {
|
|
121
250
|
await security(['delete-generic-password', '-a', profile(baseUrl), '-s', SERVICE])
|
package/lib/jsonFiles.mjs
CHANGED
|
@@ -94,6 +94,10 @@ function summarize(value) {
|
|
|
94
94
|
if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length
|
|
95
95
|
if (Array.isArray(value.codegenWarnings)) summary.codegenWarningCount = value.codegenWarnings.length
|
|
96
96
|
if (value.schema) summary.schemaAvailable = true
|
|
97
|
+
for (const key of ['configuration', 'configurationReview', 'changes']) {
|
|
98
|
+
if (object(value[key]) && Buffer.byteLength(JSON.stringify(value[key])) <= 8000) summary[key] = value[key]
|
|
99
|
+
else if (object(value[key])) summary[`${key}Available`] = true
|
|
100
|
+
}
|
|
97
101
|
return summary
|
|
98
102
|
}
|
|
99
103
|
|
package/lib/previewStore.mjs
CHANGED
|
@@ -4,7 +4,9 @@ import { dirname, join } from 'node:path'
|
|
|
4
4
|
|
|
5
5
|
import { credentialPath } from './credentials.mjs'
|
|
6
6
|
|
|
7
|
-
|
|
7
|
+
import { digestJson } from './contract.mjs'
|
|
8
|
+
|
|
9
|
+
const HASH = /^[a-f0-9]{64}$/u
|
|
8
10
|
const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
|
|
9
11
|
|
|
10
12
|
function previewDirectory(baseUrl) {
|
|
@@ -33,49 +35,33 @@ function isObject(value) {
|
|
|
33
35
|
return value !== null && typeof value === 'object' && !Array.isArray(value)
|
|
34
36
|
}
|
|
35
37
|
|
|
36
|
-
function isPreviewBody(value) {
|
|
37
|
-
return isObject(value) && value.entryMode === 'manual' &&
|
|
38
|
-
isObject(value.design) && value.design.source === 'manual' && isObject(value.evidence)
|
|
39
|
-
}
|
|
40
|
-
|
|
41
38
|
function summary(record) {
|
|
42
|
-
return {
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
decisions: record.body.evidence.decisions,
|
|
49
|
-
createdAt: record.createdAt,
|
|
50
|
-
expiresAt: record.expiresAt,
|
|
51
|
-
}
|
|
39
|
+
return { previewId: record.previewId, requestId: record.requestId, digest: record.digest,
|
|
40
|
+
lane: record.lane ?? record.body.purpose ?? 'design', entryMode: record.body.entryMode,
|
|
41
|
+
systemName: record.body.design?.config?.systemName ?? '', decisions: record.body.evidence?.decisions ?? [],
|
|
42
|
+
contractId: record.contractId ?? null, previewBinding: record.previewBinding ?? null,
|
|
43
|
+
createdAt: record.createdAt, expiresAt: record.expiresAt,
|
|
44
|
+
requiresPreview: record.version !== 2 || Date.parse(record.expiresAt) <= Date.now() }
|
|
52
45
|
}
|
|
53
46
|
|
|
54
|
-
export async function savePreview(baseUrl,
|
|
55
|
-
|
|
56
|
-
if (
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
const frozenBody = JSON.parse(serializedBody)
|
|
61
|
-
const previewId = randomUUID()
|
|
62
|
-
const record = {
|
|
63
|
-
version: 1,
|
|
64
|
-
baseUrl,
|
|
65
|
-
previewId,
|
|
66
|
-
requestId: randomUUID(),
|
|
67
|
-
digest,
|
|
68
|
-
body: frozenBody,
|
|
69
|
-
bodySha256: sha256(JSON.stringify(stableJson(frozenBody))),
|
|
70
|
-
createdAt: new Date(now).toISOString(),
|
|
71
|
-
expiresAt: new Date(now + PREVIEW_TTL_MS).toISOString(),
|
|
47
|
+
export async function savePreview(baseUrl, lane, body, checked) {
|
|
48
|
+
const digest = lane === 'sql' ? checked.fingerprint : checked.digest
|
|
49
|
+
if (!HASH.test(digest) || !HASH.test(checked.contractId) || !HASH.test(checked.previewBinding) ||
|
|
50
|
+
!UUID_PATTERN.test(checked.requestId) || !/^\d{10,13}\.[a-f0-9]{64}\.[a-f0-9]{64}$/u.test(checked.previewSeal) ||
|
|
51
|
+
!Number.isFinite(Date.parse(checked.expiresAt)) || Date.parse(checked.expiresAt) <= Date.now()) {
|
|
52
|
+
throw new Error('正式预览回执缺少有效的请求身份、签名或版本')
|
|
72
53
|
}
|
|
54
|
+
const previewId = randomUUID()
|
|
55
|
+
const facts = { version: 2, lane, baseUrl, previewId, requestId: checked.requestId, digest,
|
|
56
|
+
body, contractId: checked.contractId, previewBinding: checked.previewBinding, previewSeal: checked.previewSeal,
|
|
57
|
+
createdAt: new Date().toISOString(), expiresAt: checked.expiresAt }
|
|
58
|
+
const record = { ...facts, checksum: digestJson(facts) }
|
|
73
59
|
await mkdir(previewDirectory(baseUrl), { recursive: true, mode: 0o700 })
|
|
74
60
|
await writeFile(previewPath(baseUrl, previewId), JSON.stringify(record), { flag: 'wx', mode: 0o600 })
|
|
75
61
|
return summary(record)
|
|
76
62
|
}
|
|
77
63
|
|
|
78
|
-
export async function readPreview(baseUrl, previewId
|
|
64
|
+
export async function readPreview(baseUrl, previewId) {
|
|
79
65
|
let record
|
|
80
66
|
try {
|
|
81
67
|
record = JSON.parse(await readFile(previewPath(baseUrl, previewId), 'utf8'))
|
|
@@ -87,17 +73,11 @@ export async function readPreview(baseUrl, previewId, now = Date.now()) {
|
|
|
87
73
|
if (record?.body?.entryMode === 'ai') {
|
|
88
74
|
throw new Error('旧版 ai 预览已失效;请用 manual 重新预检,不能复用旧摘要')
|
|
89
75
|
}
|
|
90
|
-
if (!isObject(record) || !
|
|
91
|
-
record.
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
sha256(JSON.stringify(stableJson(record.body))) !== record.bodySha256) {
|
|
96
|
-
throw new Error('本地预览已变化,请重新预检')
|
|
97
|
-
}
|
|
98
|
-
if (!Number.isFinite(Date.parse(record.expiresAt)) || Date.parse(record.expiresAt) <= now) {
|
|
99
|
-
throw new Error('本地预览已过期,请重新预检后创建项目')
|
|
100
|
-
}
|
|
76
|
+
if (!isObject(record) || !isObject(record.body) || record.baseUrl !== baseUrl || record.previewId !== previewId ||
|
|
77
|
+
!UUID_PATTERN.test(record.requestId) || !HASH.test(record.digest)) throw new Error('本地预览已变化,请重新预检')
|
|
78
|
+
if (record.version === 1 && record.bodySha256 === sha256(JSON.stringify(stableJson(record.body)))) return record
|
|
79
|
+
const { checksum, ...facts } = record
|
|
80
|
+
if (record.version !== 2 || checksum !== digestJson(facts)) throw new Error('本地预览已变化,请重新预检')
|
|
101
81
|
return record
|
|
102
82
|
}
|
|
103
83
|
|
|
@@ -117,7 +97,8 @@ export async function resumePreview(baseUrl, previewId) {
|
|
|
117
97
|
try { available.push(await readPreview(baseUrl, file.slice(0, -5))) }
|
|
118
98
|
catch { /* 过期或损坏的预览不参与自动恢复;文件保留供用户检查。 */ }
|
|
119
99
|
}
|
|
120
|
-
if (!available.length) throw new Error('
|
|
100
|
+
if (!available.length) throw new Error('尚无可恢复的本地预览')
|
|
101
|
+
if (available.length > 1) throw new Error('存在多个冻结预览,请使用当前任务检查点中的 previewId')
|
|
121
102
|
available.sort((left, right) => right.createdAt.localeCompare(left.createdAt))
|
|
122
103
|
return summary(available[0])
|
|
123
104
|
}
|