@evomap/evolver-core 2.0.0-beta.19 → 2.0.0-beta.22

package/dist/hub/sanitize.js

@@ -10,12 +10,9 @@ export const REDACTED = '[REDACTED]';
 const REDACT_PATTERNS = [
     // API keys & tokens (generic)
     /Bearer\s+[A-Za-z0-9-._~+/]+=*/g,
-    /"?node_secret"?\s*[:=]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
+    /\bBasic\s+[A-Za-z0-9+/]{8,}={0,2}(?=$|[\s,;)}\]])/gi,
+    /\b(?:AIza[0-9A-Za-z_-]{20,}|ya29\.[0-9A-Za-z_-]{20,}|(?:xai|hf|glpat|dop_v1|pk_live|pk_test|sk_live|sk_test|rk_live|rk_test)[-_][A-Za-z0-9_-]{16,}|sq0(?:atp|csp)-[A-Za-z0-9_-]{16,})\b/g,
     /sk-[A-Za-z0-9]{20,}/g,
-    /"?token"?[=:]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
-    /api[_-]?key[=:]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
-    /secret[=:]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
-    /password[=:]\s*["']?[^\s"',;)}\]]{6,}["']?/gi,
     // GitHub tokens (ghp_, gho_, ghu_, ghs_, ghr_, github_pat_)
     /ghp_[A-Za-z0-9]{36,}/g,
     /gho_[A-Za-z0-9]{36,}/g,
@@ -55,6 +52,120 @@ const REDACT_PATTERNS = [
     /\.env\.[a-zA-Z]+\b/g,
     /(?<=[\\/])\.env\b/g,
 ];
+// 结构化执行诊断可能来自 JSON、YAML 或键值输出，字段名与分隔符之间也可能有空格。
+// 这里只识别字段前缀，值由下面两个小解析器分别读取：带引号的值读取到匹配的闭合引号，
+// 不带引号的值在空白或结构分隔符处停止，避免把凭据后的普通说明文字一起吞掉。
+const STRUCTURED_CREDENTIAL_PREFIX = /(?<![A-Za-z0-9_-])(["']?)(node[_-]?secret|access[_-]?token|refresh[_-]?token|id[_-]?token|session[_-]?token|api[_-]?key|client[_-]?secret|private[_-]?key|token|secret|password|passwd|passphrase|credential|credentials|authorization|auth|bearer|cookie|dsn|webhook|signature)\1(\s*[:=]\s*)/gi;
+const OPAQUE_CREDENTIAL_PATTERN = /(?<![A-Za-z0-9_-])[A-Za-z0-9][A-Za-z0-9._~+=-]{31,}(?![A-Za-z0-9_-])/g;
+const AMBIGUOUS_STRUCTURED_KEYS = new Set([
+    'token', 'secret', 'credential', 'credentials', 'authorization', 'auth', 'cookie', 'signature',
+]);
+const DIAGNOSTIC_STATUS_VALUE = /^(?:ok|success|successful|succeeded|failed|failure|pending|missing|invalid|expired|mismatch|denied|unavailable|refresh needed|not configured|not found|none|null|true|false|enabled|disabled|present|absent|unknown|skipped|unsupported)$/i;
+const DIAGNOSTIC_ASSIGNMENT_VALUE = /^(?:policy|mode|state|status|configured|enabled)=(?:ok|success|successful|succeeded|failed|failure|pending|missing|invalid|expired|mismatch|denied|unavailable|none|null|true|false|enabled|disabled|present|absent|unknown|skipped|unsupported)$/i;
+function unquoteStructuredValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'")))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function shouldRedactStructuredField(key, rawValue) {
+    const normalizedKey = key.toLowerCase().replace(/[_-]/g, '');
+    if (!AMBIGUOUS_STRUCTURED_KEYS.has(normalizedKey))
+        return true;
+    const value = unquoteStructuredValue(rawValue);
+    const normalizedStatus = value.replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+    if (!value
+        || /^\[redacted\]$/i.test(value)
+        || DIAGNOSTIC_STATUS_VALUE.test(normalizedStatus)
+        || DIAGNOSTIC_ASSIGNMENT_VALUE.test(value))
+        return false;
+    if (/^(?:Bearer|Digest|NTLM|Negotiate|AWS)\s+\S+/i.test(value))
+        return true;
+    if (/^Basic\s+[A-Za-z0-9+/]{8,}={0,2}$/i.test(value))
+        return true;
+    // 歧义字段只有在值呈现紧凑凭据形态时才脱敏，保留“auth: denied by policy”等诊断上下文。
+    return !/\s/.test(value) && value.length >= 8;
+}
+function readQuotedStructuredValue(input, start) {
+    const quote = input[start];
+    if (quote !== '"' && quote !== "'")
+        return undefined;
+    let escaped = false;
+    for (let index = start + 1; index < input.length; index += 1) {
+        const char = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === quote) {
+            const end = index + 1;
+            return { end, raw: input.slice(start, end), quote };
+        }
+        if (char === '\r' || char === '\n')
+            break;
+    }
+    return undefined;
+}
+function readUnquotedStructuredValue(input, start) {
+    if (input.startsWith(REDACTED, start)) {
+        return { end: start + REDACTED.length, raw: REDACTED, quote: '' };
+    }
+    let end = start;
+    while (end < input.length) {
+        const char = input[end] ?? '';
+        if (/[\s,;)}\]]/.test(char) || (char === ':' && /\s/.test(input[end + 1] ?? '')))
+            break;
+        end += 1;
+    }
+    if (end === start)
+        return undefined;
+    return { end, raw: input.slice(start, end), quote: '' };
+}
+function redactStructuredCredentials(input) {
+    let cursor = 0;
+    let output = '';
+    STRUCTURED_CREDENTIAL_PREFIX.lastIndex = 0;
+    let match = STRUCTURED_CREDENTIAL_PREFIX.exec(input);
+    while (match) {
+        if (match.index < cursor) {
+            match = STRUCTURED_CREDENTIAL_PREFIX.exec(input);
+            continue;
+        }
+        const valueStart = STRUCTURED_CREDENTIAL_PREFIX.lastIndex;
+        const span = readQuotedStructuredValue(input, valueStart) ?? readUnquotedStructuredValue(input, valueStart);
+        if (!span) {
+            match = STRUCTURED_CREDENTIAL_PREFIX.exec(input);
+            continue;
+        }
+        output += input.slice(cursor, valueStart);
+        output += shouldRedactStructuredField(match[2] ?? '', span.raw)
+            ? `${span.quote}${REDACTED}${span.quote}`
+            : span.raw;
+        cursor = span.end;
+        STRUCTURED_CREDENTIAL_PREFIX.lastIndex = span.end;
+        match = STRUCTURED_CREDENTIAL_PREFIX.exec(input);
+    }
+    return cursor === 0 ? input : output + input.slice(cursor);
+}
+function isOpaqueCredential(candidate) {
+    const compact = candidate.replace(/[._~+/=-]/g, '');
+    const classes = Number(/[a-z]/.test(compact)) + Number(/[A-Z]/.test(compact)) + Number(/[0-9]/.test(compact));
+    if (compact.length < 24 || classes < 3 || /^[0-9a-f]+$/i.test(compact))
+        return false;
+    const frequencies = new Map();
+    for (const char of compact)
+        frequencies.set(char, (frequencies.get(char) ?? 0) + 1);
+    const entropy = [...frequencies.values()].reduce((sum, count) => {
+        const probability = count / compact.length;
+        return sum - probability * Math.log2(probability);
+    }, 0);
+    return entropy >= 3.5;
+}
 // Post-filter allowlist (ported from v1 src/gep/sanitize.js, PR #151): strings the patterns above — and the path
 // anonymizer below — WILL catch but that are not actually sensitive. If any entry matches a captured string it is
 // kept verbatim instead of being redacted / anonymized / flagged as a leak. Keeping this as a post-filter rather
@@ -104,6 +215,9 @@ export function redactString(s) {
         p.lastIndex = 0;
         out = out.replace(p, (m) => (isAllowlisted(m) ? m : REDACTED));
     }
+    out = redactStructuredCredentials(out);
+    OPAQUE_CREDENTIAL_PATTERN.lastIndex = 0;
+    out = out.replace(OPAQUE_CREDENTIAL_PATTERN, (candidate) => (isOpaqueCredential(candidate) ? REDACTED : candidate));
     for (const [p, rep] of ANONYMIZE_PATTERNS) {
         p.lastIndex = 0;
         out = out.replace(p, (m) => (isAllowlisted(m) ? m : rep));

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * as daemon from './daemon/index.js';
 export * as material from './material/index.js';
 export * as mailbox from './mailbox/index.js';
 export * as assetstore from './assetstore/index.js';
+export * as assetrepair from './assetrepair/index.js';
 export * as strategy from './strategy/index.js';
 export * as algo from './algo/index.js';
 export * as personality from './personality/index.js';
@@ -27,4 +28,5 @@ export * as util from './util/index.js';
 export * as trace from './trace/index.js';
 export * as issueReporter from './issueReporter/index.js';
 export * as feedback from './feedback/index.js';
+export * as compatibility from './modelCompatibility.js';
 export { isValidationCommandAllowed } from './verify/validation.js';

package/dist/index.js

@@ -10,6 +10,7 @@ export * as daemon from './daemon/index.js';
 export * as material from './material/index.js';
 export * as mailbox from './mailbox/index.js';
 export * as assetstore from './assetstore/index.js';
+export * as assetrepair from './assetrepair/index.js';
 export * as strategy from './strategy/index.js';
 export * as algo from './algo/index.js';
 export * as personality from './personality/index.js';
@@ -27,5 +28,6 @@ export * as util from './util/index.js';
 export * as trace from './trace/index.js';
 export * as issueReporter from './issueReporter/index.js';
 export * as feedback from './feedback/index.js';
+export * as compatibility from './modelCompatibility.js';
 // Re-export commonly used validation functions at top level for convenience
 export { isValidationCommandAllowed } from './verify/validation.js';

package/dist/mailbox/ipcServer.d.ts

@@ -22,6 +22,8 @@ export interface IpcRouteContext {
     route: string;
     now: number;
     store: MailboxStore;
+    /** 请求连接中止或响应提前关闭时触发；长任务应将其传给可取消的宿主执行器。 */
+    signal?: AbortSignal;
     readJson: () => Promise<unknown>;
     json: (code: number, body: unknown) => void;
 }

package/dist/mailbox/ipcServer.js

@@ -84,6 +84,20 @@ export class MailboxIpcServer {
         return new Promise((resolve, reject) => this.server.close((e) => (e ? reject(e) : resolve())));
     }
     async handle(req, res) {
+        const requestAbort = new AbortController();
+        const abortRequest = () => {
+            if (!requestAbort.signal.aborted)
+                requestAbort.abort(new Error('ipc_request_aborted'));
+        };
+        // 请求/响应 close 既可能表示客户端提前断开，也可能只是正常响应结束。
+        // 只有响应尚未完成时才传播取消，避免正常返回把后台验证误判为客户端取消。
+        const abortIfResponseOpen = () => {
+            if (!res.writableEnded && !res.writableFinished)
+                abortRequest();
+        };
+        req.once('aborted', abortIfResponseOpen);
+        req.socket.once('close', abortIfResponseOpen);
+        res.once('close', abortIfResponseOpen);
         try {
             const ra = req.socket.remoteAddress ?? '';
             if (!LOOPBACK.has(ra))
@@ -109,6 +123,7 @@ export class MailboxIpcServer {
                     route,
                     now,
                     store: this.store,
+                    signal: requestAbort.signal,
                     readJson: () => this.readJson(req),
                     json: (code, body) => this.json(res, code, body),
                 });
@@ -215,6 +230,11 @@ export class MailboxIpcServer {
         catch (e) {
             return this.json(res, 400, { error: e instanceof Error ? e.message : String(e), code: 'invalid_request' });
         }
+        finally {
+            req.off('aborted', abortIfResponseOpen);
+            req.socket.off('close', abortIfResponseOpen);
+            res.off('close', abortIfResponseOpen);
+        }
     }
     readJson(req) {
         return new Promise((resolve, reject) => {

package/dist/mailbox/store.d.ts

@@ -1,14 +1,59 @@
 import { type Envelope, type Status, type CreateEnvelopeInput } from './envelope.js';
 export declare const MAX_ATTEMPTS = 5;
 export declare const DEFAULT_IMPORT_JSONL_MAX_LINE_BYTES: number;
+export declare const DEFAULT_IMPORT_JSONL_MAX_BYTES: number;
+export declare const DEFAULT_IMPORT_JSONL_MAX_RECORDS = 100000;
 export declare const MAILBOX_CLAIM_OWNER: unique symbol;
 export type ClaimedEnvelope = Envelope & {
     readonly [MAILBOX_CLAIM_OWNER]: string;
 };
+export type MailboxImportRecord = Readonly<{
+    kind: 'message';
+    envelope: Readonly<Envelope>;
+}> | Readonly<{
+    kind: 'update';
+    id: string;
+    fields: Readonly<Record<string, unknown>>;
+}>;
+export type PreparedMailboxImport = Readonly<{
+    records: readonly MailboxImportRecord[];
+    sourceRecords: number;
+    messageCandidates: number;
+    uniqueMessageCandidates: number;
+    updateCandidates: number;
+}>;
+export type MailboxImportPreview = Readonly<{
+    sourceRecords: number;
+    messageCandidates: number;
+    uniqueMessageCandidates: number;
+    updateCandidates: number;
+    insertedMessages: number;
+    updatedMessages: number;
+    managedMessages: number;
+    protectedMessages: number;
+}>;
+export type MailboxJsonlImportErrorCode = 'line_too_large' | 'journal_too_large' | 'too_many_records' | 'invalid_utf8' | 'invalid_json' | 'invalid_record' | 'invalid_update' | 'unsupported_operation' | 'invalid_message';
+export declare class MailboxJsonlImportError extends Error {
+    readonly code: MailboxJsonlImportErrorCode;
+    readonly line: number;
+    constructor(code: MailboxJsonlImportErrorCode, line: number, message: string);
+}
 export declare function mailboxClaimOwner(envelope: Envelope): string | undefined;
 export declare function expBackoffMs(attempt: number): number;
 /** Read one mailbox state value without creating, migrating, or taking write ownership of the database. */
 export declare function readMailboxState(path: string, key: string): string | undefined;
+/**
+ * Parse and normalize a V1 mailbox journal without opening or mutating a V2 mailbox.
+ * The returned batch is sealed so dry-run and apply can consume the exact same records.
+ */
+export declare function prepareMailboxJsonlImport(source: string | number, options?: {
+    maxLineBytes?: number;
+    maxBytes?: number;
+    maxRecords?: number;
+    now?: number;
+}): PreparedMailboxImport;
+/** Preview a prepared import against an optional existing mailbox without creating or migrating it. */
+export declare function previewPreparedMailboxImport(batch: PreparedMailboxImport, mailboxPath?: string): MailboxImportPreview;
 /** mailbox sqlite 引擎 (WAL + busy_timeout). 状态机 pending→in_flight→done/failed/expired + 租约 + 重试/DLQ. */
 export declare class MailboxStore {
     private readonly db;
@@ -117,8 +162,13 @@ export declare class MailboxStore {
     markProcessedIf(sourceKey: string, markerKey: string, markerResult: unknown, now: number, matches: (sourceResult: unknown) => boolean): boolean;
     deleteProcessed(keys: readonly string[]): void;
     private messageClaimOwner;
-    /** v1 messages.jsonl → sqlite 迁移(幂等可重入). */
+    /** Build the target-aware plan shared by preview and apply. */
+    private buildPreparedImportPlan;
+    /** Preview the exact import result against the current mailbox snapshot without writing to it. */
+    previewPreparedImport(batch: PreparedMailboxImport): MailboxImportPreview;
+    private writeImportedEnvelopeFields;
+    /** Apply a parsed batch; planning and writes share one transaction and one normalized journal. */
+    importPrepared(batch: PreparedMailboxImport): number;
     importJsonl(source: string | number): number;
-    private applyImportedV1Update;
     close(): void;
 }