dsh-code-security 0.3.8 → 0.4.1

package/lib/scanner.js

@@ -9,6 +9,8 @@ import { createHash } from 'node:crypto';
 import { DEFAULT_EXCLUDE_DIRS } from './config.js';
 import { languageForFile, RULES } from './rules.js';
 import { policyExcludesDir, policyIgnores } from './policy.js';
+import { protectFinding, isHighEntropyToken } from './privacy.js';
+import { sanitizedHtmlLines } from './syntax.js';
 const DISABLE_NEXT = /secure-review-disable-next-line(?:\s+([\w,-]+))?/;
 const DISABLE_LINE = /secure-review-disable-line(?:\s+([\w,-]+))?/;
 function isComment(line) {
@@ -48,31 +50,12 @@ function shouldScanFile(file) {
         return true;
     return TEXT_EXTENSIONS.test(file);
 }
-/** Shannon 熵；只对 24 位以上且以字母数字为主的 token 判分。 */
-function shannon(text) {
-    if (text.length < 16)
-        return 0;
-    const counts = new Map();
-    for (const char of text)
-        counts.set(char, (counts.get(char) ?? 0) + 1);
-    let entropy = 0;
-    for (const count of counts.values()) {
-        const p = count / text.length;
-        entropy -= p * Math.log2(p);
-    }
-    return entropy;
-}
 const TOKEN_PATTERN = /['"]([A-Za-z0-9+/=_-]{24,})['"]/g;
-const HIGH_ENTROPY_THRESHOLD = 3.8;
 function detectHighEntropy(line, lineNumber, rel, rule) {
     const findings = [];
     for (const match of line.matchAll(TOKEN_PATTERN)) {
         const token = match[1];
-        if (/^[0-9]+$/.test(token))
-            continue;
-        if (!/\d/.test(token))
-            continue;
-        if (shannon(token) < HIGH_ENTROPY_THRESHOLD)
+        if (!isHighEntropyToken(token))
             continue;
         const id = makeId(rule.id, rel, lineNumber, token.slice(0, 32));
         findings.push({
@@ -138,7 +121,7 @@ function scanFileRule(entries, rel, rule, disabledNext, selectedLines) {
     return checkBlock();
 }
 /** 对带行号的文本行应用规则（全量扫描与 git diff 增量扫描共用）。 */
-export function scanLineSet(entries, rel, policy, selectedLines) {
+export function scanLineSet(entries, rel, policy, selectedLines, sanitized = new Set()) {
     const language = languageForFile(rel);
     const findings = [];
     const applied = RULES.filter((rule) => (rule.languages.includes(language) || rule.languages.includes('any')) && !policyIgnores(policy, rule.id, rel));
@@ -156,6 +139,8 @@ export function scanLineSet(entries, rel, policy, selectedLines) {
         for (const rule of applied) {
             if (rule.id === 'SEC-304')
                 continue;
+            if (rule.id === 'SEC-009' && sanitized.has(entry.line))
+                continue;
             if (shouldSkipLine(rule, currentDisable) || shouldSkipLine(rule, prevDisable.get(entry.line)))
                 continue;
             if (rule.fileLevel === true)
@@ -188,7 +173,7 @@ export function scanLineSet(entries, rel, policy, selectedLines) {
         if (finding !== undefined)
             findings.push(finding);
     }
-    return findings;
+    return findings.map(finding => protectFinding({ ...finding, engine: 'builtin', evidence: 'pattern' }));
 }
 /** 扫描单个文件内容，按语言与行应用规则。 */
 export function scanText(content, file, rel, policy) {
@@ -196,7 +181,7 @@ export function scanText(content, file, rel, policy) {
     const entries = lines.map((text, index) => ({ line: index + 1, text }));
     // Match file rules over contiguous lines, sharing locations and suppressions
     // with incremental scans without joining unrelated diff hunks.
-    return scanLineSet(entries, rel, policy);
+    return scanLineSet(entries, rel, policy, undefined, languageForFile(rel) === 'javascript' ? sanitizedHtmlLines(content) : new Set());
 }
 /** Apply the same exclusions to full scans, directly selected files and diffs. */
 export function isExcludedPath(rel, policy) {
@@ -211,6 +196,10 @@ export async function scanPath(options) {
     let filesSkipped = 0;
     const findings = [];
     const relRoot = path.relative(cwd, root).split(path.sep).join('/');
+    let complete = true;
+    const warnings = [];
+    const incomplete = (message) => { complete = false; if (warnings.length < 50)
+        warnings.push(message); };
     const visit = async (absolute, rel) => {
         options.signal?.throwIfAborted();
         if (isExcludedPath(rel, policy)) {
@@ -223,11 +212,14 @@ export async function scanPath(options) {
         }
         catch {
             filesSkipped += 1;
+            incomplete('无法读取 ' + rel);
             return;
         }
         options.signal?.throwIfAborted();
         if (stat.isSymbolicLink()) {
             filesSkipped += 1;
+            if (absolute === root)
+                incomplete('目标为链接，未读取链接内容');
             return;
         }
         if (stat.isDirectory()) {
@@ -239,11 +231,14 @@ export async function scanPath(options) {
             }
             catch {
                 filesSkipped += 1;
+                incomplete('无法遍历 ' + rel);
                 return;
             }
             for (const entry of entries) {
-                if (filesScanned >= maxFiles)
+                if (filesScanned >= maxFiles) {
+                    incomplete('已达到文件数量上限');
                     return;
+                }
                 await visit(path.join(absolute, entry.name), rel === '' ? entry.name : rel + '/' + entry.name);
             }
             return;
@@ -254,6 +249,7 @@ export async function scanPath(options) {
         }
         if (stat.size > maxFileBytes) {
             filesSkipped += 1;
+            incomplete(rel + ' 超过文件大小上限');
             return;
         }
         let buffer;
@@ -262,6 +258,7 @@ export async function scanPath(options) {
         }
         catch {
             filesSkipped += 1;
+            incomplete('无法读取 ' + rel);
             return;
         }
         if (fileHasBinary(buffer)) {
@@ -271,11 +268,12 @@ export async function scanPath(options) {
         filesScanned += 1;
         options.signal?.throwIfAborted();
         const text = new TextDecoder('utf-8', { fatal: false }).decode(buffer);
+        options.onDocument?.({ file: rel, text });
         findings.push(...scanText(text, absolute, rel, policy));
     };
     await visit(root, relRoot);
     findings.sort((a, b) => severityRank(b.severity) - severityRank(a.severity) || a.file.localeCompare(b.file) || a.line - b.line);
-    return { root, filesScanned, filesSkipped, findings, durationMs: Date.now() - started };
+    return { root, filesScanned, filesSkipped, findings, durationMs: Date.now() - started, complete, warnings };
 }
 function severityRank(severity) {
     return severity === 'critical' ? 4 : severity === 'high' ? 3 : severity === 'medium' ? 2 : 1;

package/lib/state.d.ts

@@ -5,7 +5,14 @@
  * @module dsh-code-security/state
  */
 import type { Finding } from './scanner.js';
+import type { SourceEngine } from './config.js';
+import type { EngineCoverage } from './engines.js';
+import type { ScanScope } from './audit.js';
 export interface ScanStateEntry {
+    complete?: boolean;
+    coverage?: EngineCoverage[];
+    engines?: SourceEngine[];
+    scope?: ScanScope;
     mode: string;
     target: string;
     time: string;

package/lib/state.js

@@ -6,19 +6,33 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
 import lockfile from 'proper-lockfile';
+import { evidenceFingerprint, protectFinding, redactText } from './privacy.js';
 const STATE_FILE = 'state.json';
 const HISTORY_LIMIT = 50;
 export function findingFingerprint(finding) {
-    const file = finding.file.split(path.sep).join('/').replace(/^(?:\.\/)+/, '');
-    const raw = finding.ruleId + '|' + file + '|' + finding.snippet.trim();
-    return createHash('sha256').update(raw).digest('hex');
+    return evidenceFingerprint(finding);
 }
 export function statePath(stateDir) {
     return path.join(stateDir, STATE_FILE);
 }
 export async function loadState(stateDir) {
+    const initial = await readState(stateDir);
+    const protectedState = protectState(initial);
+    if (JSON.stringify(initial) === JSON.stringify(protectedState))
+        return protectedState;
+    const unlock = await lockfile.lock(stateDir, { retries: { retries: 30, minTimeout: 25, maxTimeout: 100 } });
+    try {
+        const state = protectState(await readState(stateDir));
+        await writeState(stateDir, state);
+        return state;
+    }
+    finally {
+        await unlock();
+    }
+}
+async function readState(stateDir) {
     try {
         const info = await fs.lstat(statePath(stateDir));
         if (!info.isFile() || info.isSymbolicLink() || info.size > 16 * 1024 * 1024)
@@ -39,6 +53,13 @@ export async function loadState(stateDir) {
         return { last: null, history: [], baseline: null };
     }
 }
+function protectState(state) {
+    const clean = (entry) => {
+        const findings = entry.findings.map(protectFinding);
+        return { ...entry, ...('reason' in entry ? { reason: redactText(entry.reason) } : {}), findings, fingerprints: findings.map(findingFingerprint) };
+    };
+    return { last: state.last ? clean(state.last) : null, history: state.history.map(clean), baseline: state.baseline ? clean(state.baseline) : null };
+}
 function isEntry(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -72,7 +93,7 @@ export async function saveState(stateDir, entry, signal) {
     const unlock = await lockfile.lock(stateDir, { retries: { retries: 30, minTimeout: 25, maxTimeout: 100 } });
     try {
         signal?.throwIfAborted();
-        const state = await loadState(stateDir);
+        const state = protectState(await readState(stateDir));
         state.last = entry;
         state.history.unshift(entry);
         state.history = state.history.slice(0, HISTORY_LIMIT);
@@ -88,7 +109,7 @@ export async function saveBaseline(stateDir, baseline, signal) {
     const unlock = await lockfile.lock(stateDir, { retries: { retries: 30, minTimeout: 25, maxTimeout: 100 } });
     try {
         signal?.throwIfAborted();
-        const state = await loadState(stateDir);
+        const state = protectState(await readState(stateDir));
         state.baseline = baseline;
         return await writeState(stateDir, state, signal);
     }
@@ -99,7 +120,7 @@ export async function saveBaseline(stateDir, baseline, signal) {
 async function writeState(stateDir, state, signal) {
     signal?.throwIfAborted();
     const file = statePath(stateDir);
-    const tmp = file + '.tmp-' + randomUUID(), bytes = JSON.stringify(state, null, 2);
+    const tmp = file + '.tmp-' + randomUUID(), bytes = JSON.stringify(protectState(state), null, 2);
     if (Buffer.byteLength(bytes) > 16 * 1024 * 1024)
         throw new Error('安全扫描记录超过 16 MiB，本次没有保存。');
     try {

package/lib/syntax.d.ts

@@ -0,0 +1 @@
+export declare function sanitizedHtmlLines(content: string): Set<number>;

package/lib/syntax.js

@@ -0,0 +1,43 @@
+/** A narrow sanitizer check with real lexical bindings, never string-based suppression. */
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+const traverse = (traverseModule.default ?? traverseModule);
+export function sanitizedHtmlLines(content) {
+    const sinks = new Map();
+    const add = (line, safe) => { if (line)
+        sinks.set(line, [...sinks.get(line) ?? [], safe]); };
+    function trustedSanitizer(node, at) {
+        if (node?.type !== 'CallExpression' || node.arguments.length !== 1 || node.callee.type !== 'MemberExpression' || node.callee.computed || node.callee.object.type !== 'Identifier' || node.callee.property.type !== 'Identifier' || node.callee.property.name !== 'sanitize')
+            return false;
+        const binding = at.scope.getBinding(node.callee.object.name);
+        if (!binding?.constant || !binding.path.isImportDefaultSpecifier() && !binding.path.isImportNamespaceSpecifier())
+            return false;
+        if (!binding.path.parentPath.isImportDeclaration() || binding.path.parentPath.node.source.value !== 'dompurify')
+            return false;
+        return binding.referencePaths.every(ref => {
+            const member = ref.parentPath, call = member?.parentPath;
+            return member?.isMemberExpression() && !member.node.computed && member.node.property.type === 'Identifier' && member.node.property.name === 'sanitize' && call?.isCallExpression() && call.node.callee === member.node;
+        });
+    }
+    try {
+        const ast = parse(content, { sourceType: 'unambiguous', plugins: ['typescript', 'jsx'], allowReturnOutsideFunction: true });
+        traverse(ast, {
+            AssignmentExpression(at) {
+                const left = at.node.left;
+                if (left.type === 'MemberExpression' && !left.computed && left.property.type === 'Identifier' && left.property.name === 'innerHTML')
+                    add(left.loc?.start.line, trustedSanitizer(at.node.right, at));
+            },
+            JSXAttribute(at) {
+                if (at.node.name.type !== 'JSXIdentifier' || at.node.name.name !== 'dangerouslySetInnerHTML')
+                    return;
+                const expression = at.node.value?.type === 'JSXExpressionContainer' ? at.node.value.expression : undefined;
+                const html = expression?.type === 'ObjectExpression' ? expression.properties.find(prop => prop.type === 'ObjectProperty' && !prop.computed && prop.key.type === 'Identifier' && prop.key.name === '__html') : undefined;
+                add(at.node.loc?.start.line, html?.type === 'ObjectProperty' && trustedSanitizer(html.value, at));
+            },
+        });
+    }
+    catch {
+        return new Set();
+    }
+    return new Set([...sinks].filter(([, safe]) => safe.length > 0 && safe.every(Boolean)).map(([line]) => line));
+}

package/lib/tools.d.ts

@@ -27,4 +27,6 @@ export interface SecureToolDefinition {
     execute(args: unknown, exec: unknown): Promise<unknown>;
     timeoutMs?: number;
 }
+/** Reject ambiguous scopes before reading files, running git, or replacing scan state. */
+export declare function scanArguments(raw: unknown, allowed?: readonly string[]): Record<string, unknown>;
 export declare function buildSecureTools(cfg: ResolvedSecureConfig, cwd: string, runner: ProcessRunner): SecureToolDefinition[];

package/lib/tools.js

@@ -11,11 +11,11 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { optionalString, requiredString } from './config.js';
 import { buildExtraTools } from './extra.js';
-import { runGitDiff, scanDiff } from './diff.js';
 import { loadPolicy, normalizePolicy, POLICY_FILE, savePolicy } from './policy.js';
 import { ruleCategory } from './rules.js';
-import { scanPath } from './scanner.js';
 import { compareFingerprints, countFindings, findingFingerprint, loadState, saveState, splitByBaseline } from './state.js';
+import { runSourceCheck, sourceEngines } from './audit.js';
+import { probeEngine, databaseHealth } from './engines.js';
 const SEVERITY_ORDER = { critical: 4, high: 3, medium: 2, low: 1 };
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 function compileParameters(spec) {
@@ -31,12 +31,14 @@ function compileParameters(spec) {
             node.description = prop.description;
         if (prop?.enum !== undefined)
             node.enum = prop.enum;
+        if (prop?.items !== undefined)
+            node.items = prop.items;
         properties[key] = node;
     }
     return { type: 'object', properties, ...(required.length > 0 ? { required } : {}) };
 }
 /** Reject ambiguous scopes before reading files, running git, or replacing scan state. */
-function scanArguments(raw, allowed = ['target']) {
+export function scanArguments(raw, allowed = ['target', 'engines']) {
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
         throw new Error('扫描参数必须是对象。请用 { target: "文件或目录" } 限定范围；扫描整个工作区请传 {}。');
     }
@@ -54,6 +56,8 @@ function scanArguments(raw, allowed = ['target']) {
     if (Object.hasOwn(args, 'staged') && typeof args.staged !== 'boolean') {
         throw new Error('扫描参数 staged 必须是布尔值 true 或 false。');
     }
+    if (Object.hasOwn(args, 'includeUntracked') && typeof args.includeUntracked !== 'boolean')
+        throw new Error('includeUntracked 必须是布尔值');
     return args;
 }
 const findingSchema = {
@@ -117,7 +121,7 @@ export function buildSecureTools(cfg, cwd, runner) {
             signal?.throwIfAborted();
             const workspace = context?.agent?.session?.header?.cwd || cwd;
             const resolved = { ...cfg, stateDir: cfg.stateDirRelative ? path.resolve(workspace, cfg.stateDirRelative) : cfg.stateDir };
-            const scopedRunner = { run: (argv, options) => runner.run(argv, { ...options, cwd: workspace, signal }) };
+            const scopedRunner = { run: (argv, options) => runner.run(argv, { ...options, cwd: options?.cwd ?? workspace, signal: options?.signal && signal ? AbortSignal.any([options.signal, signal]) : options?.signal ?? signal }) };
             const selected = buildWorkspaceTools(resolved, workspace, scopedRunner, signal).find(row => row.name === tool.name);
             return selected.execute(args, exec);
         } }));
@@ -129,6 +133,7 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
         description: '扫描工作区（或指定文件/目录），用确定性规则检测注入、弱加密、硬编码密钥、危险配置等问题。使用 target 字符串限定范围，不接受 paths/files 等参数；{} 表示整个工作区。结果写入 .code-security 状态供 secure_fix_verify 对比。',
         parameters: { ...compileParameters({
                 target: { type: 'string', description: '要扫描的文件或目录（可选，缺省扫描整个工作区）。' },
+                engines: { type: 'array', items: { type: 'string', enum: ['builtin', 'betterleaks', 'semgrep'] }, description: '可选引擎，默认使用配置（初始仅 builtin）。' },
             }), additionalProperties: false },
         output: { schema: scanSchema, render: renderFindings },
         async execute(rawArgs) {
@@ -136,7 +141,8 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
             const target = optionalString(args, 'target');
             const policy = await loadPolicy(cwd);
             const failOn = policy.failOn ?? cfg.failOn;
-            const result = await scanPath({ cwd, target, maxFiles: cfg.maxFiles, maxFileBytes: cfg.maxFileBytes, policy, signal });
+            const engines = sourceEngines(args.engines, cfg.engines);
+            const result = await runSourceCheck({ kind: 'scan', ...(target ? { target } : {}) }, cfg, cwd, runner, engines, policy, signal);
             const state = await loadState(stateDir);
             const counts = countFindings(result.findings);
             const split = splitByBaseline(result.findings, state.baseline);
@@ -148,9 +154,10 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
                 findings: result.findings,
                 fingerprints: result.findings.map(findingFingerprint),
                 counts,
+                complete: result.complete, coverage: result.coverage, engines, scope: result.scope,
             };
             const stateFile = await saveState(stateDir, entry, signal);
-            return { ...result, counts, newFindings: split.fresh, newCounts: countFindings(split.fresh), acceptedFindings: split.accepted, baseline: state.baseline, passed: verdictOf(split.fresh, failOn), failOn, stateFile };
+            return { ...result, counts, newFindings: split.fresh, newCounts: countFindings(split.fresh), acceptedFindings: split.accepted, baseline: state.baseline, passed: result.complete && verdictOf(split.fresh, failOn), failOn, stateFile };
         },
         timeoutMs: 120000,
     };
@@ -161,16 +168,18 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
                 base: { type: 'string', description: 'git 基线（默认 HEAD）。' },
                 target: { type: 'string', description: '限定文件路径（可选）。' },
                 staged: { type: 'boolean', description: '审查已暂存改动（git diff --cached，默认 false）。' },
+                includeUntracked: { type: 'boolean', description: '同时检查未跟踪的新文件（默认 false，staged 模式不包含它们）。' },
+                engines: { type: 'array', items: { type: 'string', enum: ['builtin', 'betterleaks', 'semgrep'] }, description: '可选增强引擎；同样只报告涉及新增行的问题。' },
             }), additionalProperties: false },
         output: { schema: scanSchema, render: renderFindings },
         async execute(rawArgs) {
-            const args = scanArguments(rawArgs, ['base', 'target', 'staged']);
+            const args = scanArguments(rawArgs, ['base', 'target', 'staged', 'engines', 'includeUntracked']);
             const base = optionalString(args, 'base') ?? 'HEAD';
             const target = optionalString(args, 'target');
             const policy = await loadPolicy(cwd);
             const failOn = policy.failOn ?? cfg.failOn;
-            const diff = await runGitDiff(runner, cwd, base, target, 30000, args.staged === true);
-            const result = scanDiff(diff, cwd, policy);
+            const engines = sourceEngines(args.engines, cfg.engines);
+            const result = await runSourceCheck({ kind: 'diff', base, staged: args.staged === true, ...(args.includeUntracked === true ? { includeUntracked: true } : {}), ...(target ? { target } : {}) }, cfg, cwd, runner, engines, policy, signal);
             const state = await loadState(stateDir);
             const counts = countFindings(result.findings);
             const split = splitByBaseline(result.findings, state.baseline);
@@ -182,17 +191,19 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
                 findings: result.findings,
                 fingerprints: result.findings.map(findingFingerprint),
                 counts,
+                complete: result.complete, coverage: result.coverage, engines, scope: result.scope,
             };
             await saveState(stateDir, entry, signal);
-            return { root: base, filesChanged: result.filesChanged, filesScanned: result.filesScanned, filesSkipped: result.filesSkipped, addedLines: result.addedLines, findings: result.findings, counts, newFindings: split.fresh, newCounts: countFindings(split.fresh), acceptedFindings: split.accepted, baseline: state.baseline, passed: verdictOf(split.fresh, failOn), failOn, durationMs: 0 };
+            return { ...result, counts, newFindings: split.fresh, newCounts: countFindings(split.fresh), acceptedFindings: split.accepted, baseline: state.baseline, passed: result.complete && verdictOf(split.fresh, failOn), failOn };
         },
         timeoutMs: 60000,
     };
     const secureFixVerify = {
         name: 'secure_fix_verify',
-        description: '复扫并与上次扫描基线对比，输出已关闭、仍存在、新引入的问题指纹。用于修复后确认没有按下葫芦浮起瓢。',
+        description: '按上次相同范围与引擎复查，输出已关闭、仍存在、新增问题。只有完整复查才更新状态和判定关闭；规则不再命中不等同于相关测试通过。',
         parameters: { ...compileParameters({
                 target: { type: 'string', description: '复扫文件或目录（可选，缺省扫描整个工作区）。' },
+                engines: { type: 'array', items: { type: 'string', enum: ['builtin', 'betterleaks', 'semgrep'] }, description: '默认沿用上次扫描引擎；需与上次相同，避免未执行就宣称修好。' },
             }), additionalProperties: false },
         output: {
             schema: {
@@ -215,24 +226,41 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
             const target = optionalString(args, 'target');
             const policy = await loadPolicy(cwd);
             const state = await loadState(stateDir);
-            const result = await scanPath({ cwd, target, maxFiles: cfg.maxFiles, maxFileBytes: cfg.maxFileBytes, policy, signal });
+            const engines = sourceEngines(args.engines, state.last?.engines ?? cfg.engines);
+            if (state.last && !state.last.scope && state.last.mode.startsWith('diff:'))
+                throw new Error('旧版增量记录缺少完整范围，请先重新执行 secure_diff / Rerun secure_diff to upgrade this legacy diff record before rechecking');
+            const scope = state.last?.scope ?? { kind: 'scan', ...(state.last?.target && state.last.target !== '.' ? { target: state.last.target } : {}) };
+            if (target !== undefined && path.resolve(cwd, target) !== path.resolve(cwd, scope.target ?? '.'))
+                throw new Error('复查范围必须与上次扫描相同；请先对新范围执行 secure_scan');
+            if (state.last?.engines && [...engines].sort().join() !== [...state.last.engines].sort().join())
+                throw new Error('复查引擎必须与上次扫描相同');
+            const result = await runSourceCheck(scope, cfg, cwd, runner, engines, policy, signal);
             if (state.last === null) {
                 return { baselineMissing: true, baselineTime: '', closedCount: 0, remainingCount: 0, freshCount: result.findings.length, closed: [], remaining: [], fresh: result.findings, passed: false };
             }
             const current = result.findings.map(findingFingerprint);
             const cmp = compareFingerprints(state.last.findings.map(findingFingerprint), current);
             const byFingerprint = new Map(result.findings.map((finding) => [findingFingerprint(finding), finding]));
-            const closed = cmp.closed.map((fp) => state.last.findings.find((finding) => findingFingerprint(finding) === fp)).filter((x) => x !== undefined);
+            const closed = result.complete ? cmp.closed.map((fp) => state.last.findings.find((finding) => findingFingerprint(finding) === fp)).filter((x) => x !== undefined) : [];
             const remaining = cmp.remaining.map((fp) => byFingerprint.get(fp)).filter((x) => x !== undefined);
             const fresh = cmp.fresh.map((fp) => byFingerprint.get(fp)).filter((x) => x !== undefined);
+            if (result.complete)
+                await saveState(stateDir, {
+                    ...state.last, time: new Date().toISOString(), mode: 'verify:' + scope.kind,
+                    filesScanned: result.filesScanned, findings: result.findings,
+                    fingerprints: current, counts: countFindings(result.findings),
+                    complete: true, coverage: result.coverage, engines, scope,
+                }, signal);
             return {
                 baselineMissing: false,
                 baselineTime: state.last.time,
                 closedCount: closed.length,
                 remainingCount: remaining.length,
                 freshCount: fresh.length,
+                complete: result.complete, coverage: result.coverage,
+                unverified: result.complete ? [] : state.last.findings,
                 closed, remaining, fresh,
-                passed: fresh.length === 0 && remaining.length === 0,
+                passed: result.complete && fresh.length === 0 && remaining.length === 0,
             };
         },
         timeoutMs: 120000,
@@ -274,6 +302,7 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
             const split = splitByBaseline(last.findings, state.baseline);
             return {
                 hasScan: true,
+                time: last.time, scope: last.scope, engines: last.engines ?? ['builtin'],
                 stateFile: stateDir,
                 policy,
                 counts: last.counts,
@@ -282,7 +311,9 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
                 acceptedCounts: countFindings(split.accepted),
                 byRule: [...byRule.entries()].sort((a, b) => b[1] - a[1]).map(([rule, count]) => ({ rule, count, category: ruleCategory(rule) })),
                 byFile: [...byFile.entries()].sort((a, b) => b[1] - a[1]).slice(0, 50).map(([file, count]) => ({ file, count })),
-                passed: verdictOf(split.fresh, failOn),
+                passed: last.complete !== false && verdictOf(split.fresh, failOn),
+                complete: last.complete !== false, coverage: last.coverage ?? [], findings: last.findings,
+                newFindings: split.fresh, acceptedFindings: split.accepted,
                 historyCount: state.history.length,
             };
         },
@@ -361,9 +392,10 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
                 throw new Error('尚无扫描结果，请先执行 secure_scan 或 secure_diff。');
             const text = format === 'sarif' ? buildSarif(state.last.findings, cwd) : buildMarkdown(state.last.findings, state.last.target);
             signal?.throwIfAborted();
-            if (target !== undefined)
-                await writeFile(target, text, 'utf8');
-            return { format, path: target ?? '', text, findingCount: state.last.findings.length };
+            const destination = target === undefined ? undefined : path.resolve(cwd, target);
+            if (destination !== undefined)
+                await writeFile(destination, text, { encoding: 'utf8', mode: 0o600, signal });
+            return { format, path: destination ?? '', text, findingCount: state.last.findings.length };
         },
         timeoutMs: 30000,
     };
@@ -390,10 +422,11 @@ function buildWorkspaceTools(cfg, cwd, runner, signal) {
             checks.push({ name: '严重度门禁', ok: true, detail: 'failOn=' + cfg.failOn });
             checks.push({ name: '状态目录', ok: true, detail: cfg.stateDir });
             checks.push({ name: '工作目录', ok: cwd !== '', detail: cwd });
-            return { ok: true, plugin: 'dsh-code-security', checks };
+            const engines = await Promise.all(['osv', 'betterleaks', 'semgrep'].map(engine => probeEngine(engine, cfg, runner)));
+            return { ok: true, plugin: 'dsh-code-security', checks, engines, configuredEngines: cfg.engines, database: await databaseHealth(cfg) };
         },
     };
-    return [secureScan, secureDiff, secureFixVerify, secureReport, secureExport, ...buildExtraTools(cfg, cwd, signal), policyShow, policySet, secureHealth];
+    return [secureScan, secureDiff, secureFixVerify, secureReport, secureExport, ...buildExtraTools(cfg, cwd, signal, runner), policyShow, policySet, secureHealth];
 }
 function buildMarkdown(findings, target) {
     const lines = ['# 安全审查报告', '', '目标：' + target, '', '| 严重度 | 规则 | CWE | 文件:行 | 说明 |', '| :-- | :-- | :-- | :-- | :-- |'];

package/lib/workbench.d.ts

@@ -0,0 +1,30 @@
+import { type SecureToolDefinition } from './tools.js';
+import { type ResolvedSecureConfig } from './config.js';
+export declare const SECURITY_WORKBENCH_ROUTE = "/api/dsh-code-security/workbench";
+export declare class SecurityWorkbench {
+    readonly cfg: ResolvedSecureConfig;
+    private readonly automaticProblems;
+    private readonly jobs;
+    private readonly tools;
+    readonly directory: string;
+    onAutoChanged?: (root: string, enabled: boolean) => void;
+    constructor(cfg: ResolvedSecureConfig, options: {
+        directory?: string;
+        tools: (cfg: ResolvedSecureConfig, cwd: string) => SecureToolDefinition[];
+    });
+    private catalog;
+    private update;
+    remember(workspace: string, sessionId?: string): Promise<void>;
+    configFor(root: string): Promise<ResolvedSecureConfig>;
+    autoEnabled(root: string): Promise<boolean>;
+    automaticProblem(root: string, reason?: string): void;
+    private workspace;
+    private report;
+    runAutomatic(root: string, signal?: AbortSignal): Promise<any>;
+    private safeResult;
+    run(root: string, name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<any>;
+    action(body: Record<string, unknown>): Promise<any>;
+    fetch(request: Request): Promise<Response>;
+    dispose(): Promise<void>;
+}
+export declare function installSecurityWorkbench(ctx: any, workbench: SecurityWorkbench): void;