cli-aimlock 7.0.34 → 7.0.35

package/aimlock-runtime.mjs

@@ -209,7 +209,7 @@ const RESPONSE_SCHEMA = "aimlock.skill.response/1.1";
 const ERROR_SCHEMA = "aimlock.skill.error/1.0";
 const CONTRACT_SCHEMA = "aimlock.scope-contract/1.0";
 const COMPILER_NAME = "aimlock";
-const COMPILER_VERSION = "v7.0.34";
+const COMPILER_VERSION = "v7.0.35";
 const KEEP_ALIVE_SECONDS = 90;
 const KEEP_ALIVE_MESSAGE = "智能目标持续执行中，请勿关闭！";
 const BYPASS_LINE_BUDGET = 500;

package/brain-client-files.mjs

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto'
+import { constants } from 'node:fs'
+import { lstat, open, realpath, mkdir, writeFile, readFile } from 'node:fs/promises'
+import { relative, resolve, isAbsolute } from 'node:path'
+
+const MAX_FILE_BYTES = 2_000_000
+const MAX_CONTEXT_CHARACTERS = 6_000
+export function validateBrainPath(path) {
+  if (typeof path !== 'string' || !path || path.length > 500 || isAbsolute(path)
+    || /[\\:\u0000-\u001f\u007f]/.test(path) || path.split('/').some((part) => !part || part === '.' || part === '..')
+    || /(?:^|\/)(?:\.env(?:\.[^/]*)?|\.git|\.ssh|node_modules|id_rsa|id_ed25519)(?:\/|$)|\.(?:pem|p12|key)$/i.test(path)) {
+    throw new Error('Brain target must be a safe relative project file')
+  }
+}
+
+async function checkedAncestors(root, path) {
+  const canonicalRoot = await realpath(root)
+  let current = canonicalRoot
+  for (const part of path.split('/').slice(0, -1)) {
+    current = resolve(current, part)
+    let status
+    try { status = await lstat(current) }
+    catch (error) { if (error.code === 'ENOENT') continue; throw error }
+    if (!status.isDirectory() || status.isSymbolicLink()) throw new Error('Brain target has an unsafe parent')
+  }
+  return canonicalRoot
+}
+
+export async function inspectBrainTarget(root, path) {
+  validateBrainPath(path)
+  const canonicalRoot = await checkedAncestors(root, path)
+  const target = resolve(canonicalRoot, path)
+  let status
+  try { status = await lstat(target) }
+  catch (error) { if (error.code === 'ENOENT') return { path, sha256: null, context: '' }; throw error }
+  if (!status.isFile() || status.isSymbolicLink() || status.size > MAX_FILE_BYTES) throw new Error('Brain target is not a bounded regular file')
+  const file = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW)
+  try {
+    const opened = await file.stat()
+    if (opened.dev !== status.dev || opened.ino !== status.ino || !opened.isFile()) throw new Error('Brain target changed during inspection')
+    const bytes = Buffer.alloc(MAX_FILE_BYTES + 1)
+    let length = 0
+    while (length < bytes.length) {
+      const chunk = await file.read(bytes, length, bytes.length - length, length)
+      if (!chunk.bytesRead) break
+      length += chunk.bytesRead
+    }
+    if (length > MAX_FILE_BYTES) throw new Error('Brain target exceeds the file limit')
+    const final = await lstat(target)
+    const inside = relative(canonicalRoot, await realpath(target))
+    if (inside === '..' || inside.startsWith('../') || isAbsolute(inside)
+      || final.dev !== opened.dev || final.ino !== opened.ino || final.mtimeMs !== opened.mtimeMs) {
+      throw new Error('Brain target changed during inspection')
+    }
+    const contents = bytes.subarray(0, length)
+    if (contents.includes(0)) throw new Error('Brain context must be a text file')
+    return { path, sha256: createHash('sha256').update(contents).digest('hex'),
+      context: contents.toString('utf8').slice(0, MAX_CONTEXT_CHARACTERS) }
+  } finally { await file.close() }
+}
+
+export async function brainStateDirectory(root, parts) {
+  const canonicalRoot = await realpath(root)
+  let directory = canonicalRoot
+  for (const part of ['.aimlock', ...parts]) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(part) && part !== '.aimlock') throw new Error('Brain state path is invalid')
+    directory = resolve(directory, part)
+    try { await mkdir(directory, { mode: 0o700 }) }
+    catch (error) { if (error.code !== 'EEXIST') throw error }
+    const status = await lstat(directory)
+    if (!status.isDirectory() || status.isSymbolicLink()) throw new Error('Brain state directory is unsafe')
+  }
+  return directory
+}
+
+export async function saveBrainRequest(root, request, digest) {
+  const directory = await brainStateDirectory(root, ['brain-requests'])
+  const path = resolve(directory, request.requestId + '.json')
+  try { await writeFile(path, JSON.stringify(request), { mode: 0o600, flag: 'wx' }) }
+  catch (error) {
+    if (error.code !== 'EEXIST') throw error
+    const status = await lstat(path)
+    if (!status.isFile() || status.isSymbolicLink() || status.size > MAX_FILE_BYTES) throw new Error('Saved Brain request is unsafe')
+    if (digest(JSON.parse(await readFile(path, 'utf8'))) !== digest(request)) {
+      throw new Error('Brain request ID is already bound to different local input')
+    }
+  }
+}

package/brain-client.mjs

@@ -0,0 +1,170 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { readFile, writeFile } from 'node:fs/promises'
+import { inspectBrainTarget, brainStateDirectory, saveBrainRequest } from './brain-client-files.mjs'
+export { inspectBrainTarget } from './brain-client-files.mjs'
+import { resolve } from 'node:path'
+import { brainClientAuthorization, transportFailureCode } from './broker.mjs'
+import { executeCommand } from './aimlock-chain-process.mjs'
+
+export const BRAIN_ENDPOINT = 'https://cli.tax/api/v1/brain'
+const REQUEST_SCHEMA = 'brain.planning-request/1.0'
+const RESPONSE_SCHEMA = 'brain.planning-response/1.0'
+const PLAN_SCHEMA = 'brain.execution-plan/1.0'
+const MAX_INPUT_BYTES = 256_000
+const TIMEOUT_MS = 120_000
+const HASH_PATTERN = /^[0-9a-f]{64}$/
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const OPERATIONS = new Set(['plan', 'status', 'report', 'validate'])
+
+export function canonicalBrainJson(value) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return JSON.stringify(value)
+  if (typeof value === 'number' && Number.isFinite(value)) return JSON.stringify(value)
+  if (Array.isArray(value)) return '[' + value.map(canonicalBrainJson).join(',') + ']'
+  if (!value || typeof value !== 'object') throw new Error('Brain protocol value must be JSON')
+  return '{' + Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+    .map(([key, item]) => JSON.stringify(key) + ':' + canonicalBrainJson(item)).join(',') + '}'
+}
+
+export function brainClientDigest(value) {
+  return createHash('sha256').update(canonicalBrainJson(value)).digest('hex')
+}
+
+function exact(value, keys, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some((key) => !keys.includes(key))
+    || keys.some((key) => !Object.hasOwn(value, key))) throw new Error(label + ' has invalid fields')
+}
+
+export async function invokeBrain(operation, input, dependencies = {}) {
+  if (!OPERATIONS.has(operation)) throw new Error('Unknown Brain operation')
+  const endpoint = dependencies.endpoint ?? BRAIN_ENDPOINT
+  const context = { endpoint, displayName: 'Brain planning' }
+  const environment = dependencies.environment ?? process.env
+  const authorization = await brainClientAuthorization(context, environment, dependencies.credentialAccess)
+  const body = JSON.stringify({ operation, input })
+  if (Buffer.byteLength(body) > MAX_INPUT_BYTES) throw new Error('Brain request exceeds the size limit')
+  let response
+  try {
+    response = await (dependencies.request ?? fetch)(endpoint, {
+      method: 'POST', redirect: 'error', headers: { Authorization: authorization, 'Content-Type': 'application/json' },
+      body, signal: AbortSignal.timeout(TIMEOUT_MS),
+    })
+  } catch (error) {
+    throw new Error('Brain transport failed (' + transportFailureCode(error) + '); query status before submitting another plan')
+  }
+  const payload = await readBrainResponse(response)
+  if (!response.ok) {
+    const code = typeof payload?.code === 'string' ? payload.code : 'BRAIN_HTTP_ERROR'
+    throw new Error('Brain request failed: HTTP ' + response.status + ' (' + code + ')')
+  }
+  if (payload?.schemaVersion !== RESPONSE_SCHEMA || !UUID_PATTERN.test(payload.planId)
+    || !UUID_PATTERN.test(payload.requestId)
+    || !['planning', 'ready', 'reported', 'verified', 'failed', 'expired'].includes(payload.status)) {
+    throw new Error('Brain response envelope is invalid')
+  }
+  if ((operation === 'plan' && payload.requestId !== input.requestId)
+    || (operation !== 'plan' && (input.planId ? payload.planId !== input.planId : payload.requestId !== input.requestId))) throw new Error('Brain response identity does not match')
+  if (payload.plan !== null && (payload.plan?.schemaVersion !== PLAN_SCHEMA
+    || payload.plan.planId !== payload.planId || !HASH_PATTERN.test(payload.planDigest)
+    || brainClientDigest(payload.plan) !== payload.planDigest)) throw new Error('Brain response plan digest is invalid')
+  return payload
+}
+
+export async function prepareBrainRequest(root, specification) {
+  exact(specification, ['requestId', 'goal', 'maxChangedLines', 'targets', 'checks'], 'Brain specification')
+  if (!UUID_PATTERN.test(specification.requestId) || typeof specification.goal !== 'string' || !specification.goal.trim()
+    || !Number.isSafeInteger(specification.maxChangedLines) || specification.maxChangedLines < 1
+    || !Array.isArray(specification.targets) || !specification.targets.length || specification.targets.length > 64
+    || new Set(specification.targets).size !== specification.targets.length) throw new Error('Brain specification is invalid')
+  const targets = []
+  for (const path of specification.targets) targets.push(await inspectBrainTarget(root, path))
+  return { schemaVersion: REQUEST_SCHEMA, ...specification, targets }
+}
+
+export function validateBrainHandoff(request, response) {
+  const plan = response.plan
+  if (response.status !== 'ready' || plan?.schemaVersion !== PLAN_SCHEMA || response.requestId !== request.requestId
+    || response.planId !== plan.planId || brainClientDigest(plan) !== response.planDigest) throw new Error('Brain plan is not ready')
+  const targets = request.targets.map(({ path, sha256 }) => ({ path, sha256 }))
+  if (brainClientDigest(plan.targets) !== brainClientDigest(targets)
+    || brainClientDigest(plan.checks) !== brainClientDigest(request.checks)
+    || brainClientDigest(plan.contract.allowedPaths) !== brainClientDigest(targets.map((target) => target.path))
+    || plan.contract.maxChangedLines !== request.maxChangedLines || plan.contract.allowDeleteFiles !== false) {
+    throw new Error('Brain plan changed the local authorization')
+  }
+  if (!Array.isArray(plan.nodes) || !plan.nodes.length
+    || plan.nodes.some((node) => !targets.some((target) => target.path === node.path))) throw new Error('Brain plan targets are invalid')
+  return plan
+}
+
+export async function collectBrainReport(root, handoff, environment = process.env) {
+  exact(handoff, ['request', 'response'], 'Brain handoff')
+  const plan = validateBrainHandoff(handoff.request, handoff.response)
+  if (typeof environment.PATH !== 'string' || !environment.PATH) throw new Error('Execution PATH is required')
+  const reportId = randomUUID()
+  const directory = await brainStateDirectory(root, ['brain-reports', reportId])
+  const evidence = []
+  for (const check of plan.checks) {
+    exact(check, ['id', 'executable', 'args', 'timeoutMs'], 'Brain check')
+    if (typeof check.id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(check.id)
+      || typeof check.executable !== 'string' || !check.executable
+      || !Array.isArray(check.args) || check.args.some((arg) => typeof arg !== 'string')
+      || !Number.isSafeInteger(check.timeoutMs) || check.timeoutMs < 1_000 || check.timeoutMs > 3_600_000) {
+      throw new Error('Brain check command is invalid')
+    }
+    const result = await executeCommand(root, {
+      executable: check.executable, args: check.args, timeoutMs: check.timeoutMs,
+      environment: { PATH: environment.PATH }, workingDirectory: '.', evidenceKind: 'test',
+    }, reportId + ':' + check.id, async () => {})
+    const digest = (value) => createHash('sha256').update(value).digest('hex')
+    evidence.push({ checkId: check.id, exitCode: result.status !== 'succeeded' && result.exitCode === 0 ? null : result.exitCode, durationMs: result.durationMs,
+      stdoutSha256: digest(result.stdout), stderrSha256: digest(result.stderr) })
+    await writeFile(resolve(directory, check.id + '.json'), JSON.stringify(result), { mode: 0o600 })
+    if (result.status === 'uncertain') throw new Error('Check process cleanup is unconfirmed; execution stopped')
+  }
+  const files = []
+  for (const node of plan.nodes) {
+    const actual = await inspectBrainTarget(root, node.path)
+    if (actual.sha256 === null) throw new Error('Planned file is missing: ' + node.path)
+    files.push({ path: node.path, sha256: actual.sha256 })
+  }
+  return { planId: plan.planId, planDigest: handoff.response.planDigest, reportId, files, evidence }
+}
+
+export async function runBrainCli(args) {
+  const [operation, root, file] = args
+  if (!['plan', 'check', 'status', 'validate'].includes(operation) || !root || !file || args.length !== 3) {
+    throw new Error('Usage: cli-aimlock brain <plan|check|status|validate> <repositoryRoot> <jsonFile>')
+  }
+  const source = await readFile(resolve(file), 'utf8')
+  if (Buffer.byteLength(source) > MAX_INPUT_BYTES) throw new Error('Brain input file exceeds the size limit')
+  const input = JSON.parse(source)
+  if (operation === 'plan') {
+    const request = await prepareBrainRequest(root, input)
+    await saveBrainRequest(root, request, brainClientDigest)
+    const response = await invokeBrain('plan', request)
+    if (response.status === 'ready') validateBrainHandoff(request, response)
+    process.stdout.write(JSON.stringify({ request, response }) + '\n')
+    return
+  }
+  const payload = operation === 'check' ? await collectBrainReport(root, input) : input
+  const response = await invokeBrain(operation === 'check' ? 'report' : operation, payload)
+  process.stdout.write(JSON.stringify(response) + '\n')
+}
+
+async function readBrainResponse(response) {
+  if (!response.body) throw new Error('Brain response body is missing')
+  const reader = response.body.getReader()
+  const chunks = []
+  let bytes = 0
+  try {
+    for (;;) {
+      const chunk = await reader.read()
+      if (chunk.done) break
+      bytes += chunk.value.byteLength
+      if (bytes > MAX_INPUT_BYTES) { await reader.cancel(); throw new Error('Brain response exceeds the size limit') }
+      chunks.push(Buffer.from(chunk.value))
+    }
+  } finally { reader.releaseLock() }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}

package/cli.mjs

@@ -4,6 +4,7 @@ import { dirname, resolve } from 'node:path'
 import { cwd, stdin, stdout } from 'node:process'
 import { createInterface } from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
+import { runBrainCli } from './brain-client.mjs'
 import { CHAIN_USAGE, runChainCli } from './aimlock-chain-cli.mjs'
 import { defaultUsage, dispatchOfficialSkillCli, runIntakeHandshake } from './installer.mjs'
 import {
@@ -185,7 +186,9 @@ async function dispatchLocal(args) {
 
 const cliPath = fileURLToPath(import.meta.url)
 if (process.argv[1] && realpathSync(resolve(process.argv[1])) === cliPath) {
-  if (process.argv[2] === 'chain') {
+  if (process.argv[2] === 'brain') {
+    await runBrainCli(process.argv.slice(3))
+  } else if (process.argv[2] === 'chain') {
     await runChainCli(process.argv.slice(3))
   } else if (process.argv[2] === 'local') {
     try {

package/package.json

@@ -3,14 +3,15 @@
     "cli-aimlock": "./cli.mjs"
   },
   "dependencies": {
-    "cli-swarm": "7.0.34"
+    "cli-swarm": "7.0.35"
   },
   "description": "Aimlock skill installer for CLI.Tax: lock a user request into an executable aim and route Blueprint, Swarm, and Calctool.",
   "exports": {
     "./coordination": "./aimlock-coordination.mjs",
     "./local-runner": "./aimlock-local-runner.mjs",
     "./runtime": "./aimlock-runtime.mjs",
-    "./chain-executor": "./aimlock-chain-executor.mjs"
+    "./chain-executor": "./aimlock-chain-executor.mjs",
+    "./brain-client": "./brain-client.mjs"
   },
   "files": [
     "cli.mjs",
@@ -33,6 +34,8 @@
     "aimlock-local-gate.mjs",
     "aimlock-local-runner.mjs",
     "aimlock-runtime.mjs",
+    "brain-client.mjs",
+    "brain-client-files.mjs",
     "skill/references/chain-executor.md"
   ],
   "license": "UNLICENSED",
@@ -42,5 +45,5 @@
     "url": "https://github.com/88208555/aimlock-clitax.git"
   },
   "type": "module",
-  "version": "7.0.34"
+  "version": "7.0.35"
 }

package/skill/SKILL.md

@@ -5,7 +5,7 @@ description: "Aimlock 仅用于大型、深度、跨模块、高风险、需要
 
 # Aimlock Skill
 
-Package version: v7.0.34
+Package version: v7.0.35
 
 Endpoint: https://cli.tax/R3mQ8kWpXn
 
@@ -165,3 +165,12 @@ Aimlock returns the protocol; it does not start a timer.
 ## 宿主持久执行
 
 使用 [chain-executor.md](references/chain-executor.md) 的显式 `chain init/resume/status/answer` 协议驱动本地持久步骤。`run` 的需求采集、远端 `nextStep` 与 `completed` 均不等于已执行。只有真实 broker/协调器/命令结果及绑定证据能推进；未答复人工裁决禁止恢复，发送后结果不确定禁止自动重发。CLI 终端不提供 OS 隔离或独立可信 runner。
+
+## 服务端沙箱规划与 IDE 执行
+
+1. 用户在模型设置中启用自己的模型地址、API Key 和模型名后，规划优先使用该配置；未启用个人模型时使用官方模型并执行有限套餐额度。个人模型失败必须明确报错，禁止自动切换模型或消耗官方额度。
+2. 准备请求 JSON，明确 requestId、目标、允许文件、最大修改行数和批准的检查命令；运行 `npx cli-aimlock@latest brain plan <repositoryRoot> <request.json>`。服务端调用模型规划，再由隔离沙箱编译结构化计划；保留返回的 request/response 交接包。
+3. 审查返回计划的允许范围、基线哈希和检查命令；完成现有 Aimlock 范围、快照和写入门禁后，由 IDE 修改代码。计划本身不授权扩大范围，不替代写入门禁。
+4. 运行 `npx cli-aimlock@latest brain check <repositoryRoot> <handoff.json>` 执行批准的检查并回传产物哈希和结果。普通 IDE 回传属于 client-reported，不能据此声称可信验证通过。
+5. 只有已批准的可信 runner 生成与本次计划和报告绑定的签名收据后，才运行 `npx cli-aimlock@latest brain validate <repositoryRoot> <validation.json>`。没有可信收据时保持已回传状态，不伪造验证。
+6. 请求发送后结果不确定时，先用 `brain status <repositoryRoot> <status.json>` 按 requestId 或 planId 查询；禁止自动重发规划或重复计费。

package/skill/skill.json

@@ -6,5 +6,5 @@
   "name": "aimlock",
   "schemaVersion": "aimlock.skill.request/1.1",
   "type": "Skill",
-  "version": "v7.0.34"
+  "version": "v7.0.35"
 }