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

package/dist/llm/upstream.js

@@ -39,15 +39,44 @@ function isOpenAiMode(upstreamMode) {
  * Warn once per process to avoid per-request spam.
  */
 let warnedDeprecatedOpenAICompatible = false;
+function hasDeprecatedOpenAICompatibleConfig(env) {
+    return [
+        env['EVOLVER_OPENAI_COMPATIBLE_BASE_URLS'],
+        env['EVOMAP_OPENAI_COMPATIBLE_BASE_URLS'],
+    ].some((value) => typeof value === 'string' && value.trim() !== '');
+}
+function explicitOpenAIBaseUrl(env) {
+    return env['EVOLVER_LLM_OPENAI_BASE_URL'] || env['EVOMAP_OPENAI_BASE_URL'] || env['OPENAI_BASE_URL'];
+}
+function hasCanonicalOpenAIMigrationPair(env) {
+    const baseUrl = env['EVOLVER_LLM_OPENAI_BASE_URL']?.trim();
+    if (!baseUrl || !env['EVOLVER_LLM_OPENAI_API_KEY']?.trim())
+        return false;
+    try {
+        normalizeOpenAIBaseUrl(baseUrl);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function warnDeprecatedOpenAICompatible(env) {
-    const deprecatedValue = env['EVOMAP_OPENAI_COMPATIBLE_BASE_URLS'] || env['EVOLVER_OPENAI_COMPATIBLE_BASE_URLS'];
-    if (!deprecatedValue || warnedDeprecatedOpenAICompatible)
+    if (!hasDeprecatedOpenAICompatibleConfig(env) || warnedDeprecatedOpenAICompatible)
         return;
     warnedDeprecatedOpenAICompatible = true;
     console.warn('[proxy] DEPRECATED: EVOMAP_OPENAI_COMPATIBLE_BASE_URLS / EVOLVER_OPENAI_COMPATIBLE_BASE_URLS is ignored for routing. ' +
-        'V2 accepts only https://*.api.openai.com/v1 via EVOLVER_LLM_OPENAI_BASE_URL, EVOMAP_OPENAI_BASE_URL, or OPENAI_BASE_URL. ' +
-        'LiteLLM / OpenRouter / Azure OpenAI-compatible hosts are not accepted on this OpenAI path — use a reverse proxy in front of api.openai.com or a non-OpenAI provider mode. ' +
-        'Remove the deprecated multi-base env var.');
+        'Manual migration is required: explicitly bind one official https://*.api.openai.com/v1 endpoint and its credential ' +
+        'with EVOLVER_LLM_OPENAI_BASE_URL and EVOLVER_LLM_OPENAI_API_KEY. ' +
+        'LiteLLM, OpenRouter, Azure OpenAI, MiniMax, DeepSeek, Moonshot, and other custom OpenAI-compatible hosts have no drop-in V2 route. ' +
+        'Do not reuse their credentials as an OpenAI credential; keep that workload outside this proxy until a supported provider-specific route exists.');
+}
+function assertDeprecatedOpenAICompatibleMigrated(env) {
+    warnDeprecatedOpenAICompatible(env);
+    if (hasDeprecatedOpenAICompatibleConfig(env) && !hasCanonicalOpenAIMigrationPair(env)) {
+        throw new Error('[proxy] manual migration of deprecated OpenAI-compatible base URLs requires an explicit '
+            + 'EVOLVER_LLM_OPENAI_BASE_URL and '
+            + 'EVOLVER_LLM_OPENAI_API_KEY migration pair before the OpenAI route can start');
+    }
 }
 /** Test helper: reset once-warn latch (unit tests only). */
 function resetDeprecatedOpenAICompatibleWarning() {
@@ -77,9 +106,23 @@ function normalizeOpenAIBaseUrl(raw) {
     }
     return value;
 }
+function openAIBaseUrlIdentity(raw) {
+    return new URL(normalizeOpenAIBaseUrl(raw)).href;
+}
+function assertDeprecatedOpenAIRequestBaseBound(env, requestBaseUrl) {
+    if (!requestBaseUrl || !hasDeprecatedOpenAICompatibleConfig(env))
+        return;
+    const canonicalBaseUrl = env['EVOLVER_LLM_OPENAI_BASE_URL'];
+    if (typeof canonicalBaseUrl !== 'string'
+        || openAIBaseUrlIdentity(requestBaseUrl) !== openAIBaseUrlIdentity(canonicalBaseUrl)) {
+        throw new Error('[proxy] request-scoped OpenAI base URL must match EVOLVER_LLM_OPENAI_BASE_URL '
+            + 'while deprecated OpenAI-compatible routing remains configured');
+    }
+}
 export function resolveOpenAIUpstreamUrl(env = process.env) {
-    warnDeprecatedOpenAICompatible(env);
-    return normalizeOpenAIBaseUrl(env['EVOLVER_LLM_OPENAI_BASE_URL'] || env['EVOMAP_OPENAI_BASE_URL'] || env['OPENAI_BASE_URL'] || DEFAULT_OPENAI_UPSTREAM_URL);
+    assertDeprecatedOpenAICompatibleMigrated(env);
+    const explicitBaseUrl = explicitOpenAIBaseUrl(env);
+    return normalizeOpenAIBaseUrl(explicitBaseUrl || DEFAULT_OPENAI_UPSTREAM_URL);
 }
 function pathForOpenAIBase(path) {
     if (path === '/v1')
@@ -478,6 +521,10 @@ export function makeOpenAIUpstream(opts = {}) {
     const headersTimeoutMs = opts.headersTimeoutMs ?? DEFAULT_HEADERS_TIMEOUT_MS;
     return async (path, body, callOpts) => {
         const env = opts.env ?? process.env;
+        // A request-scoped base override is routing data, not evidence that the daemon's
+        // legacy provider credential/base pair was deliberately migrated.
+        assertDeprecatedOpenAICompatibleMigrated(env);
+        assertDeprecatedOpenAIRequestBaseBound(env, callOpts.baseUrl);
         const baseUrl = callOpts.baseUrl ? normalizeOpenAIBaseUrl(callOpts.baseUrl) : resolveOpenAIUpstreamUrl(env);
         return fetchUpstream(`${baseUrl}${path}`, body, callOpts, buildOpenAIHeaders(callOpts.inboundHeaders, env), fetchImpl, headersTimeoutMs, 'openai', (headers) => contentTypeIncludes(headers, 'text/event-stream'));
     };

package/dist/private/accountAssetCompatibility.d.ts

@@ -25,4 +25,5 @@ interface PrivateAccountAssetCompatibilityOptions {
  * future adapter's native implementation.
  */
 export declare function withPrivateAccountAssetCompatibility<T extends object>(hubCapability: T, opts: PrivateAccountAssetCompatibilityOptions): T & PrivateAccountAssetHub;
+export declare function normalizePrivateHubBaseUrl(raw: string, env: Record<string, string | undefined>): string;
 export {};

package/dist/private/accountAssetCompatibility.js

@@ -159,14 +159,14 @@ function malformedPublishedPage() {
         context: `GET ${PRIVATE_PUBLISHED_ASSETS_PATH}`,
     });
 }
-function normalizePrivateHubBaseUrl(raw, env) {
+export function normalizePrivateHubBaseUrl(raw, env) {
     const normalized = raw.trim().replace(/\/+$/, '');
     assertPrivateCompatibilityUrlSecure(normalized, env);
     const parsed = new URL(normalized);
-    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    if (parsed.username || parsed.password || normalized.includes('?') || normalized.includes('#')) {
         throw new Error('Private Hub URL must not contain credentials, query parameters, or a fragment');
     }
-    return normalized;
+    return parsed.href.replace(/[/]+$/, '');
 }
 function assertPrivateCompatibilityUrlSecure(url, env) {
     let parsed;

package/dist/private/adapterLoader.js

@@ -1,6 +1,6 @@
 import { hub as hubNs } from '@evomap/evolver-core';
 import { createHash } from 'node:crypto';
-import { withPrivateAccountAssetCompatibility, } from './accountAssetCompatibility.js';
+import { normalizePrivateHubBaseUrl, withPrivateAccountAssetCompatibility, } from './accountAssetCompatibility.js';
 const DEFAULT_PRIVATE_ADAPTER_MODULE = '@evomap/evolver-adapter-private';
 export function resolvePrivateEnterpriseToken(env) {
     return firstEnv(env, 'EVOMAP_ENTERPRISE_TOKEN', 'EVOMAP_PRIVATE_HUB_TOKEN', 'PHUB_ENTERPRISE_TOKEN', 'PRIVATE_HUB_ENTERPRISE_TOKEN');
@@ -33,12 +33,13 @@ export async function connectPrivateProxyHub(opts) {
     if (!token && !usableInvitationToken && !nodeSecret) {
         throw new Error('EVOMAP_HUB_MODE=private 需要 A2A_NODE_SECRET / EVOMAP_NODE_SECRET、A2A_INVITATION_TOKEN 或 EVOMAP_ENTERPRISE_TOKEN');
     }
+    const hubUrl = normalizePrivateHubBaseUrl(opts.hubUrl, opts.env);
     const moduleName = opts.env['EVOMAP_PRIVATE_ADAPTER_MODULE']?.trim() || DEFAULT_PRIVATE_ADAPTER_MODULE;
     const connectPrivateHub = await loadConnectPrivateHub(moduleName, opts.importer ?? ((specifier) => import(specifier)));
     const now = opts.now ?? (() => Date.now());
     const subject = resolvePrivateEnterpriseSubject(opts.env);
     const baseConnectionOptions = {
-        hubUrl: opts.hubUrl,
+        hubUrl,
         senderId: opts.senderId,
         env: opts.env,
         now,
@@ -79,7 +80,7 @@ export async function connectPrivateProxyHub(opts) {
         hub.agentDirectory = hubNs.unsupportedAgentDirectoryCapability('private_hub_agent_directory_not_supported');
     }
     const compatibleHub = withPrivateAccountAssetCompatibility(hub, {
-        baseUrl: opts.hubUrl,
+        baseUrl: hubUrl,
         auth,
         senderId: opts.senderId,
         env: opts.env,

package/dist/router/messagesRoute.js

@@ -235,9 +235,15 @@ function sessionIdFromUserField(value) {
         }
     }
     if (parsed && typeof parsed === 'object') {
-        const sid = parsed['session_id'];
-        if (typeof sid === 'string' && sid.length > 0)
-            return safePlainSessionId(sid);
+        // Accept both spellings. The archive-side session key (agentic-trace-pipeline
+        // derive_session_key) reads `session_id ?? sessionId` from this same field, so a
+        // camelCase producer yields a `cc::<sid>` key upstream while we recorded null —
+        // the two datasets then silently fail to join. Both spellings still pass through
+        // safePlainSessionId; this widens the accepted key name, never the value guard.
+        const raw = parsed['session_id']
+            ?? parsed['sessionId'];
+        if (typeof raw === 'string' && raw.length > 0)
+            return safePlainSessionId(raw);
     }
     return '';
 }

package/dist/router/providerRoutes.js

@@ -998,9 +998,13 @@ function sessionIdFromUserField(value) {
         }
     }
     if (parsed && typeof parsed === 'object') {
-        const sid = parsed['session_id'];
-        if (typeof sid === 'string' && sid.length > 0)
-            return safePlainSessionId(sid);
+        // Accept both spellings — see the matching note in messagesRoute.ts. The
+        // archive-side session key reads `session_id ?? sessionId` from this field, so
+        // dropping camelCase here costs a join, not just a field.
+        const raw = parsed['session_id']
+            ?? parsed['sessionId'];
+        if (typeof raw === 'string' && raw.length > 0)
+            return safePlainSessionId(raw);
     }
     return '';
 }

package/dist/selfUpdate/bootstrap.d.ts

@@ -0,0 +1,162 @@
+import { spawn } from 'node:child_process';
+import { util } from '@evomap/evolver-core';
+import { type MigrationOptions } from './migration.js';
+export declare const RECOVERY_CONTROLLER_LIFECYCLE_OWNER_CAPABILITY_ENV = "EVOLVER_INTERNAL_RECOVERY_CONTROLLER_LIFECYCLE_OWNER";
+type BootstrapProcessKill = (pid: number, signal: NodeJS.Signals | 0) => boolean;
+type BootstrapSkipReason = 'already_supervised' | 'already_bootstrapped' | 'unsupported_install_shape' | 'policy_not_auto' | 'bootstrap_disabled' | 'ci_environment' | 'container_environment' | 'recent_failure' | 'migration_ambiguous' | 'bootstrap_attempt_invalid' | 'bootstrap_intent_pending' | 'bootstrap_attempt_pending';
+export interface BootstrapDecision {
+    proceed: boolean;
+    reason?: BootstrapSkipReason;
+}
+export interface BootstrapOutcome {
+    ok: boolean;
+    /**
+     * 'bootstrapped' / 'bootstrapped_lock_release_unconfirmed' / 'migrated' on success;
+     * failure/skip reason otherwise. Migration failures record 'migration_failed' /
+     * 'migration_timeout' (both cooldown-worthy).
+     */
+    reason: string;
+    detail?: string;
+    /** The child may own manager or IPC state, so the foreground proxy must exit. */
+    requiresForegroundExit?: true;
+}
+export interface BootstrapRunOptions {
+    env: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    execPath?: string;
+    argv1?: string;
+    /** Parent force-timeout; it must exceed the child's transaction budget. */
+    timeoutMs?: number;
+    /** Absolute child deadline offset. Production uses the complete transaction budget. */
+    transactionBudgetMs?: number;
+    /** Bounded wait for OS confirmation after force-terminating the process tree. */
+    terminationGraceMs?: number;
+    now?: number;
+    exists?: (path: string) => boolean;
+    readFile?: (path: string) => string;
+    writeFile?: (path: string, content: string) => void;
+    spawnFn?: typeof spawn;
+    treeKillSpawnFn?: typeof spawn;
+    processKill?: BootstrapProcessKill;
+    /** Test-only failure seam; production publication always uses the strict exclusive writer. */
+    beforeIntentPublish?: () => void;
+    /** Test-only crash seam for each durable initial-publication boundary. */
+    afterIntentPublicationStep?: (step: 'create' | 'partial_write' | 'file_fsync' | 'link' | 'directory_fsync', path: string) => void;
+    /** Test-only crash seams around the atomic terminal/clear state transitions. */
+    beforeIntentTerminalFsync?: (path: string) => void;
+    afterIntentTerminalPublish?: () => void;
+    afterIntentClearRename?: () => void;
+    /** Test-only trust seams. Production always uses native owner/DACL validation. */
+    assertIntentDirectoryTrust?: (directory: string) => void;
+    assertIntentFileTrust?: (path: string) => void;
+    assertLegacyProofDirectoryTrust?: (directory: string) => void;
+    assertLegacyProofFileTrust?: (path: string) => void;
+    afterLegacyProofRead?: (path: string) => void;
+    /** Test-only process identity seams; production uses fresh native core observations. */
+    readRegistrationProcessStartIdentity?: (pid: number) => util.FileLockProcessStartIdentity | null;
+    registrationOwnerProcessStatus?: (owner: Pick<util.FileLockOwnerRecord, 'pid' | 'processStartIdentity'>) => util.FileLockOwnerProcessStatus;
+    registrationPublisherProcessStatus?: (publisher: Readonly<{
+        pid: number;
+        token: string;
+        processIdentityDigest: string;
+    }>) => util.FileLockOwnerProcessStatus;
+    /**
+     * Extra seams forwarded to the one-time npm/JS → standalone migration (migration.ts).
+     * Bootstrap-level seams (exists/readFile/writeFile/spawnFn/now/execPath) win when both
+     * are supplied, so the decision and the migration observe the same injected world.
+     */
+    migration?: MigrationOptions;
+}
+/** Lifecycle state dir mirror of evolver-cli lifecyclePaths (kept dependency-free across packages). */
+export declare function resolveBootstrapStateDir(env: NodeJS.ProcessEnv): string;
+export declare function withRecoveryControllerLifecycleOwnerCapability(env: NodeJS.ProcessEnv, owner: util.FileLockOwnerRecord): NodeJS.ProcessEnv;
+export interface PreparedRecoveryControllerLifecycleOwnerCapability {
+    env: NodeJS.ProcessEnv;
+    startupAckToken: string;
+}
+export declare function prepareRecoveryControllerLifecycleOwnerCapability(env: NodeJS.ProcessEnv, owner: util.FileLockOwnerRecord): PreparedRecoveryControllerLifecycleOwnerCapability;
+export declare function clearRecoveryControllerLifecycleOwnerCapability(env: NodeJS.ProcessEnv): void;
+export declare function publishRecoveryControllerLifecycleStartupAttestation(env: NodeJS.ProcessEnv, descriptor?: number): boolean;
+export declare function lifecycleBootstrapStatePresent(env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): boolean;
+export type BootstrapDurableStateOptions = Pick<BootstrapRunOptions, 'exists' | 'readFile' | 'assertIntentFileTrust' | 'assertLegacyProofDirectoryTrust' | 'assertLegacyProofFileTrust' | 'afterLegacyProofRead' | 'registrationOwnerProcessStatus' | 'now'> & {
+    /** Exact owner currently holding the shared lifecycle mutation lock. */
+    expectedRecoveryOwner?: util.FileLockOwnerRecord;
+};
+export interface LifecycleBootstrapOwnerLease {
+    readonly path: string;
+    readonly owner: util.FileLockOwnerRecord;
+    assertOwned(): void;
+    armProcess(pid: number): util.FileLockOwnerRecord;
+    disarmProcess(): void;
+    retainProcess(): void;
+    transferToProcess(pid: number): util.FileLockOwnerRecord;
+    release(): void;
+}
+export declare function assertSupervisedLifecycleBootstrapState(env: NodeJS.ProcessEnv, options?: BootstrapDurableStateOptions & {
+    requireLifecycleState?: boolean;
+    /** Test-only parent identity seam; production always binds to process.ppid. */
+    recoveryControllerParentPid?: number;
+}): void;
+/**
+ * Revalidate the narrow parent-owned activation window used by a newly launched recovery
+ * controller. This deliberately rejects committed supervision: callers use it only as delegated
+ * authority while the lifecycle parent still owns the mutation lock and is waiting for readiness.
+ */
+export declare function assertActiveSupervisedLifecycleBootstrapDelegation(env: NodeJS.ProcessEnv, options?: BootstrapDurableStateOptions): void;
+/**
+ * Revalidate a transaction-bound launcher before any self-update operation. Unlike the startup
+ * assertion above, this never accepts the narrow activating window used to publish readiness.
+ */
+export declare function assertCommittedLifecycleBootstrapState(env: NodeJS.ProcessEnv, options?: BootstrapDurableStateOptions): void;
+/**
+ * Serialize self-update with every lifecycle bootstrap, recovery, and manual-transition writer.
+ * Acquisition is deliberately fail-fast: a heartbeat must not block the daemon while another
+ * lifecycle owner is active. Transaction-bound launchers revalidate the committed receipt under
+ * the exact acquired generation; legacy launchers still hold and recheck the shared owner lock.
+ */
+export declare function acquireLifecycleBootstrapOwnerLease(env: NodeJS.ProcessEnv, lockOptions?: {
+    maxTries?: number;
+    waitMs?: number;
+}): LifecycleBootstrapOwnerLease;
+export declare function looksLikeContainer(exists: (path: string) => boolean, readFile: (path: string) => string): boolean;
+/** True when a recent bootstrap/migration attempt failed within the cooldown window. */
+export declare function recentBootstrapFailure(env: NodeJS.ProcessEnv, optionsOrReadFile: Pick<BootstrapRunOptions, 'exists' | 'readFile' | 'assertIntentFileTrust'> | ((path: string) => string), now: number): boolean;
+/**
+ * Decide whether an unsupervised (degraded) startup should attempt first-run bootstrap.
+ * Pure — filesystem access is injectable for tests.
+ */
+export declare function shouldBootstrap(env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, options?: Pick<BootstrapRunOptions, 'exists' | 'readFile' | 'now' | 'execPath' | 'assertIntentFileTrust'>): BootstrapDecision;
+/**
+ * Resolve the `lifecycle bootstrap` invocation for the current install shape: standalone binary,
+ * CLI entry through node, or the npm-installed @evomap/evolver-cli sibling. Returns undefined when
+ * no CLI can be located. The caller may continue only after confirming durable state is clean.
+ */
+export declare function resolveBootstrapCliInvocation(options?: Pick<BootstrapRunOptions, 'execPath' | 'argv1' | 'exists'>): {
+    command: string;
+    args: string[];
+} | undefined;
+/** Best-effort attempt marker; never throws — bootstrap bookkeeping must not break startup. */
+export declare function recordBootstrapAttempt(env: NodeJS.ProcessEnv, outcome: BootstrapOutcome, options?: Pick<BootstrapRunOptions, 'writeFile' | 'now'>): void;
+/** Spawn `evolver lifecycle bootstrap` and await its result within a bounded timeout. */
+export declare function runBootstrap(options: BootstrapRunOptions): Promise<BootstrapOutcome>;
+export type DegradedStartupBootstrapResult = {
+    disposition: 'continue';
+    handedOver: false;
+    message: string;
+} | {
+    disposition: 'handoff';
+    handedOver: true;
+    exitCode: 0;
+    message: string;
+} | {
+    disposition: 'fail_closed';
+    handedOver: false;
+    exitCode: 1;
+    message: string;
+};
+/**
+ * Orchestrate bootstrap for a degraded (default-auto, unsupervised) startup: decide, attempt,
+ * record, and produce the operator message. Never throws.
+ */
+export declare function bootstrapDegradedSelfUpdateStartup(env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, options?: Omit<BootstrapRunOptions, 'env' | 'platform'>): Promise<DegradedStartupBootstrapResult>;
+export {};