evolcore 0.0.19 → 0.0.21

package/dist/config/schema-migration.js

@@ -0,0 +1,550 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { ConfigError } from './config-manager.js';
+const SUPPORTED_BASEAGENTS = new Set(['claude', 'codex', 'gemini', 'ecagent']);
+const BASEAGENT_ALIASES = new Map([
+    ['cc', 'claude'],
+    ['claude-code', 'claude'],
+    ['claude code', 'claude'],
+    ['claudecode', 'claude'],
+    ['codex-cli', 'codex'],
+    ['codex cli', 'codex'],
+    ['gemini-cli', 'gemini'],
+    ['gemini cli', 'gemini'],
+    ['geminicli', 'gemini'],
+    ['ec-agent', 'ecagent'],
+]);
+const AUXILIARY_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function hasOwn(value, field) {
+    return Object.prototype.hasOwnProperty.call(value, field);
+}
+function readJson(file) {
+    const text = fs.readFileSync(file, 'utf8');
+    return { value: JSON.parse(text), text };
+}
+function jsonText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function canonicalBaseagent(value) {
+    const key = String(value || '').trim().toLowerCase().replace(/_/g, '-');
+    const canonical = BASEAGENT_ALIASES.get(key) || key;
+    return SUPPORTED_BASEAGENTS.has(canonical) ? canonical : undefined;
+}
+function validAid(name) {
+    const labels = name.split('.');
+    return labels.length >= 3
+        && labels.every(label => /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label));
+}
+function baseagentSource(value) {
+    return isRecord(value.baseagents)
+        ? value.baseagents
+        : isRecord(value.agents)
+            ? value.agents
+            : undefined;
+}
+function baseagentNames(value) {
+    const source = baseagentSource(value);
+    if (!source)
+        return [];
+    const names = [];
+    for (const rawName of Object.keys(source)) {
+        const name = canonicalBaseagent(rawName);
+        if (name && !names.includes(name))
+            names.push(name);
+    }
+    return names;
+}
+function inheritedContext(value, parent) {
+    const activeBaseagent = canonicalBaseagent(value.active_baseagent) || parent?.activeBaseagent;
+    const names = [...new Set([...baseagentNames(value), ...(parent?.baseagents || [])])];
+    const auxiliaryModels = { ...(parent?.auxiliaryModels || {}) };
+    const source = baseagentSource(value);
+    if (source) {
+        for (const [rawName, rawBlock] of Object.entries(source)) {
+            const name = canonicalBaseagent(rawName);
+            if (name && isRecord(rawBlock) && typeof rawBlock.auxiliaryModel === 'string' && rawBlock.auxiliaryModel.trim()) {
+                auxiliaryModels[name] = rawBlock.auxiliaryModel.trim();
+            }
+        }
+    }
+    return { activeBaseagent, baseagents: names, auxiliaryModels };
+}
+function inferStringTargets(value, parent, file, source) {
+    const active = canonicalBaseagent(value.active_baseagent) || parent.activeBaseagent;
+    if (active)
+        return [active];
+    const local = baseagentNames(value);
+    if (local.length === 1)
+        return local;
+    if (parent.baseagents.length === 1)
+        return parent.baseagents;
+    const inherited = Object.keys(parent.auxiliaryModels);
+    if (inherited.length === 1)
+        return inherited;
+    throw new Error(`${file}: cannot determine baseagent for string ${source}; `
+        + 'set active_baseagent or create one baseagents.<name> block before migration');
+}
+function legacyBuckets(value) {
+    if (!isRecord(value.responseModeParams))
+        return [];
+    const params = value.responseModeParams;
+    const keys = Object.keys(params);
+    const preferred = typeof value.responseMode === 'string' ? value.responseMode.trim() : '';
+    const ordered = [];
+    for (const key of [preferred, 'single-session', 'dual-session', ...keys.sort()]) {
+        if (key && keys.includes(key) && !ordered.includes(key))
+            ordered.push(key);
+    }
+    const buckets = [];
+    for (const modeId of ordered) {
+        const bucket = params[modeId];
+        if (isRecord(bucket) && (hasOwn(bucket, 'auxiliaryModel') || hasOwn(bucket, 'auxiliaryEffort'))) {
+            buckets.push([modeId, bucket]);
+        }
+    }
+    return buckets;
+}
+function parseLegacyModel(raw, file, source) {
+    if (typeof raw === 'string') {
+        if (!raw.trim())
+            throw new Error(`${file}: ${source} must not be empty`);
+        return { kind: 'string', value: raw.trim() };
+    }
+    if (!isRecord(raw) || Object.keys(raw).length === 0) {
+        throw new Error(`${file}: ${source} must be a non-empty model string or baseagent map`);
+    }
+    const values = [];
+    for (const [rawName, model] of Object.entries(raw)) {
+        const name = canonicalBaseagent(rawName);
+        if (!name)
+            throw new Error(`${file}: ${source}.${rawName} is not a supported baseagent`);
+        if (typeof model !== 'string' || !model.trim()) {
+            throw new Error(`${file}: ${source}.${rawName} must be a non-empty string`);
+        }
+        values.push([name, model.trim()]);
+    }
+    return { kind: 'map', values };
+}
+function setCandidate(candidates, target, value, source, file) {
+    const previous = candidates.get(target);
+    if (previous && previous.value !== value) {
+        throw new Error(`${file}: conflicting legacy auxiliary values for baseagents.${target} `
+            + `(${previous.source}=${JSON.stringify(previous.value)}, ${source}=${JSON.stringify(value)})`);
+    }
+    if (!previous)
+        candidates.set(target, { value, source });
+}
+function parseEffort(raw, file, source) {
+    if (typeof raw !== 'string' || !AUXILIARY_EFFORTS.has(raw)) {
+        throw new Error(`${file}: ${source} must be one of low, medium, high, xhigh, max`);
+    }
+    return raw;
+}
+function cloneBaseagents(source) {
+    if (!source)
+        return {};
+    return Object.fromEntries(Object.entries(source).map(([name, block]) => [name, isRecord(block) ? { ...block } : block]));
+}
+function migrateConfig(input, file, parentContext) {
+    if (!isRecord(input))
+        throw new Error(`${file}: config must be an object`);
+    const buckets = legacyBuckets(input);
+    if (buckets.length === 0)
+        return { value: input, changed: false, summary: {} };
+    const context = inheritedContext(input, parentContext);
+    const models = new Map();
+    const efforts = [];
+    for (const [modeId, bucket] of buckets) {
+        const sourcePrefix = `responseModeParams.${modeId}`;
+        if (hasOwn(bucket, 'auxiliaryModel')) {
+            const source = `${sourcePrefix}.auxiliaryModel`;
+            const parsed = parseLegacyModel(bucket.auxiliaryModel, file, source);
+            const entries = parsed.kind === 'map'
+                ? parsed.values
+                : inferStringTargets(input, context, file, source).map(name => [name, parsed.value]);
+            for (const [target, model] of entries)
+                setCandidate(models, target, model, source, file);
+        }
+        if (hasOwn(bucket, 'auxiliaryEffort')) {
+            const source = `${sourcePrefix}.auxiliaryEffort`;
+            efforts.push({ value: parseEffort(bucket.auxiliaryEffort, file, source), source });
+        }
+    }
+    const existingBaseagents = baseagentSource(input);
+    const existingModelTargets = [];
+    if (existingBaseagents) {
+        for (const [rawName, rawBlock] of Object.entries(existingBaseagents)) {
+            const name = canonicalBaseagent(rawName);
+            if (name && isRecord(rawBlock) && hasOwn(rawBlock, 'auxiliaryModel'))
+                existingModelTargets.push(name);
+        }
+    }
+    const effortTargets = models.size > 0
+        ? [...models.keys()]
+        : existingModelTargets.length > 0
+            ? [...new Set(existingModelTargets)]
+            : inferStringTargets(input, context, file, 'legacy auxiliaryEffort');
+    const nextBaseagents = cloneBaseagents(existingBaseagents);
+    let movedModels = 0;
+    let movedEfforts = 0;
+    for (const [target, candidate] of models) {
+        const current = nextBaseagents[target];
+        if (current !== undefined && !isRecord(current)) {
+            throw new Error(`${file}: baseagents.${target} must be an object`);
+        }
+        const block = isRecord(current) ? current : {};
+        if (hasOwn(block, 'auxiliaryModel') && block.auxiliaryModel !== candidate.value) {
+            throw new Error(`${file}: baseagents.${target}.auxiliaryModel conflicts with ${candidate.source}; `
+                + 'existing value is preserved only after manual resolution');
+        }
+        if (!hasOwn(block, 'auxiliaryModel')) {
+            block.auxiliaryModel = candidate.value;
+            movedModels += 1;
+        }
+        nextBaseagents[target] = block;
+    }
+    const effortsByBaseagent = new Map();
+    for (const effort of efforts) {
+        for (const target of effortTargets)
+            setCandidate(effortsByBaseagent, target, effort.value, effort.source, file);
+    }
+    for (const [target, candidate] of effortsByBaseagent) {
+        let block = nextBaseagents[target];
+        if (block === undefined && context.auxiliaryModels[target]) {
+            block = { auxiliaryModel: context.auxiliaryModels[target] };
+            nextBaseagents[target] = block;
+        }
+        if (!isRecord(block)) {
+            throw new Error(`${file}: ${candidate.source} has no migrated baseagents.${target}.auxiliaryModel`);
+        }
+        if (typeof block.auxiliaryModel !== 'string' || !block.auxiliaryModel.trim()) {
+            const inheritedModel = context.auxiliaryModels[target];
+            if (inheritedModel)
+                block.auxiliaryModel = inheritedModel;
+        }
+        if (typeof block.auxiliaryModel !== 'string' || !block.auxiliaryModel.trim()) {
+            throw new Error(`${file}: ${candidate.source} has no migrated baseagents.${target}.auxiliaryModel`);
+        }
+        if (hasOwn(block, 'auxiliaryEffort') && block.auxiliaryEffort !== candidate.value) {
+            throw new Error(`${file}: baseagents.${target}.auxiliaryEffort conflicts with ${candidate.source}; `
+                + 'existing value is preserved only after manual resolution');
+        }
+        if (!hasOwn(block, 'auxiliaryEffort')) {
+            block.auxiliaryEffort = candidate.value;
+            movedEfforts += 1;
+        }
+    }
+    const nextParams = { ...input.responseModeParams };
+    for (const [modeId, bucket] of buckets) {
+        const nextBucket = { ...bucket };
+        delete nextBucket.auxiliaryModel;
+        delete nextBucket.auxiliaryEffort;
+        nextParams[modeId] = nextBucket;
+    }
+    const next = {
+        ...input,
+        ...(Object.keys(nextBaseagents).length > 0 ? { baseagents: nextBaseagents } : {}),
+        responseModeParams: nextParams,
+    };
+    if (hasOwn(input, 'agents'))
+        delete next.agents;
+    return {
+        value: next,
+        changed: true,
+        summary: { movedModels, movedEfforts, cleanedBuckets: buckets.length },
+    };
+}
+function walkRelationConfigs(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            files.push(...walkRelationConfigs(full));
+        else if (entry.isFile() && entry.name === 'config.json')
+            files.push(full);
+    }
+    return files;
+}
+function planConfigFile(file, parentContext, changes, summary) {
+    const { value, text } = readJson(file);
+    const result = migrateConfig(value, file, parentContext);
+    if (!result.changed)
+        return result.value;
+    const after = jsonText(result.value);
+    if (after !== text)
+        changes.push({ file, kind: 'auxiliary-model', before: text, after });
+    summary.filesChanged += 1;
+    summary.movedModels += result.summary.movedModels || 0;
+    summary.movedEfforts += result.summary.movedEfforts || 0;
+    summary.cleanedBuckets += result.summary.cleanedBuckets || 0;
+    return result.value;
+}
+function planAuxiliaryModelMigration(home) {
+    const changes = [];
+    const summary = {
+        configsScanned: 0,
+        filesChanged: 0,
+        movedModels: 0,
+        movedEfforts: 0,
+        cleanedBuckets: 0,
+    };
+    const agentsRoot = path.join(home, 'agents');
+    if (!fs.existsSync(agentsRoot))
+        return { home, changes, summary };
+    const defaultsFile = path.join(agentsRoot, 'defaults.json');
+    let defaults = {};
+    if (fs.existsSync(defaultsFile)) {
+        summary.configsScanned += 1;
+        defaults = planConfigFile(defaultsFile, undefined, changes, summary);
+    }
+    const defaultsContext = inheritedContext(defaults);
+    const agentEntries = fs.readdirSync(agentsRoot, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of agentEntries) {
+        if (!entry.isDirectory() || !validAid(entry.name))
+            continue;
+        const agentDir = path.join(agentsRoot, entry.name);
+        const agentFile = path.join(agentDir, 'config.json');
+        if (!fs.existsSync(agentFile))
+            continue;
+        summary.configsScanned += 1;
+        const agent = planConfigFile(agentFile, defaultsContext, changes, summary);
+        const agentContext = inheritedContext(agent, defaultsContext);
+        for (const relationFile of walkRelationConfigs(path.join(agentDir, 'relations'))) {
+            summary.configsScanned += 1;
+            planConfigFile(relationFile, agentContext, changes, summary);
+        }
+    }
+    return { home, changes, summary };
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === 'ESRCH')
+            return false;
+        if (isRecord(error) && error.code === 'EPERM')
+            return true;
+        throw error;
+    }
+}
+function assertDaemonStopped(home) {
+    const candidates = [];
+    const pidFile = path.join(home, 'daemon.pid');
+    if (fs.existsSync(pidFile)) {
+        candidates.push({ pid: Number(fs.readFileSync(pidFile, 'utf8').trim()), source: pidFile });
+    }
+    const instanceDir = path.join(home, 'data', 'instance');
+    if (fs.existsSync(instanceDir)) {
+        for (const name of fs.readdirSync(instanceDir)) {
+            if (!/^main-\d+\.json$/.test(name))
+                continue;
+            const file = path.join(instanceDir, name);
+            try {
+                const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (isRecord(record))
+                    candidates.push({ pid: Number(record.pid), source: file });
+            }
+            catch {
+                // Invalid instance records are handled by the instance registry.
+            }
+        }
+    }
+    for (const { pid, source } of candidates) {
+        if (Number.isInteger(pid) && pid > 0 && processIsAlive(pid)) {
+            throw new Error(`EvolCore daemon appears to be running (pid=${pid}, record=${source}); stop it before migration`);
+        }
+    }
+}
+function lockPath(home) {
+    return path.join(home, 'data', 'auxiliary-model-v1-migration.lock');
+}
+function acquireLock(home) {
+    const dir = lockPath(home);
+    const ownerFile = path.join(dir, 'owner.json');
+    fs.mkdirSync(path.dirname(dir), { recursive: true });
+    try {
+        fs.mkdirSync(dir);
+    }
+    catch (error) {
+        if (!isRecord(error) || error.code !== 'EEXIST')
+            throw error;
+        let owner;
+        try {
+            owner = JSON.parse(fs.readFileSync(ownerFile, 'utf8'));
+        }
+        catch {
+            throw new Error(`Migration lock is unreadable: ${dir}`);
+        }
+        const pid = isRecord(owner) ? Number(owner.pid) : NaN;
+        if (Number.isInteger(pid) && pid > 0 && processIsAlive(pid)) {
+            throw new Error(`Another auxiliary model migration is already running (pid=${pid})`);
+        }
+        fs.rmSync(dir, { recursive: true, force: true });
+        fs.mkdirSync(dir);
+    }
+    fs.writeFileSync(ownerFile, jsonText({ pid: process.pid, createdAt: new Date().toISOString() }));
+    return () => fs.rmSync(dir, { recursive: true, force: true });
+}
+function atomicWrite(file, content) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const mode = fs.existsSync(file) ? fs.statSync(file).mode & 0o777 : 0o600;
+    const temp = `${file}.auxiliary-model-${process.pid}-${crypto.randomBytes(6).toString('hex')}.tmp`;
+    fs.writeFileSync(temp, content, { mode });
+    fs.renameSync(temp, file);
+}
+function journalPath(home) {
+    return path.join(home, 'data', 'auxiliary-model-v1-migration.json');
+}
+function writeJournal(plan, state) {
+    const journal = {
+        schemaVersion: 1,
+        state,
+        home: plan.home,
+        changes: plan.changes,
+    };
+    atomicWrite(journalPath(plan.home), jsonText(journal));
+}
+function readJournal(home) {
+    const file = journalPath(home);
+    if (!fs.existsSync(file))
+        return undefined;
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error(`Migration journal is unreadable: ${file}`);
+    }
+    if (!isRecord(raw) || raw.schemaVersion !== 1
+        || (raw.state !== 'prepared' && raw.state !== 'committed')
+        || typeof raw.home !== 'string' || path.resolve(raw.home) !== path.resolve(home)
+        || !Array.isArray(raw.changes)) {
+        throw new Error(`Migration journal is invalid: ${file}`);
+    }
+    const rootPrefix = `${path.resolve(home)}${path.sep}`;
+    const changes = [];
+    for (const item of raw.changes) {
+        if (!isRecord(item) || typeof item.file !== 'string' || typeof item.after !== 'string'
+            || (item.before !== null && typeof item.before !== 'string')) {
+            throw new Error(`Migration journal contains an unsafe change: ${file}`);
+        }
+        const target = path.resolve(item.file);
+        if (!target.startsWith(rootPrefix)) {
+            throw new Error(`Migration journal contains an unsafe change: ${file}`);
+        }
+        changes.push({
+            file: item.file,
+            kind: 'auxiliary-model',
+            before: item.before,
+            after: item.after,
+        });
+    }
+    return {
+        schemaVersion: 1,
+        state: raw.state,
+        home: raw.home,
+        changes,
+    };
+}
+function recoverJournal(home) {
+    const journal = readJournal(home);
+    if (!journal)
+        return;
+    if (journal.state === 'prepared') {
+        for (const item of [...journal.changes].reverse()) {
+            if (item.before === null)
+                fs.rmSync(item.file, { force: true });
+            else
+                atomicWrite(item.file, item.before);
+        }
+    }
+    fs.rmSync(journalPath(home), { force: true });
+}
+function applyMigration(plan) {
+    if (plan.changes.length === 0)
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backup = path.join(plan.home, 'backups', 'auxiliary-model-v1-migration', stamp);
+    fs.mkdirSync(path.join(backup, 'files'), { recursive: true });
+    for (const item of plan.changes) {
+        if (item.before === null)
+            continue;
+        const destination = path.join(backup, 'files', path.relative(plan.home, item.file));
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        fs.writeFileSync(destination, item.before);
+    }
+    fs.writeFileSync(path.join(backup, 'manifest.json'), jsonText({
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        summary: plan.summary,
+        files: plan.changes.map(item => ({
+            path: path.relative(plan.home, item.file),
+            kind: item.kind,
+        })),
+    }));
+    writeJournal(plan, 'prepared');
+    try {
+        for (const item of plan.changes)
+            atomicWrite(item.file, item.after);
+        writeJournal(plan, 'committed');
+        fs.rmSync(journalPath(plan.home), { force: true });
+    }
+    catch (error) {
+        recoverJournal(plan.home);
+        throw error;
+    }
+    return backup;
+}
+/** Plan or apply the legacy response-mode bucket to baseagent schema migration. */
+export function runAuxiliaryModelSchemaMigration(options = {}) {
+    const home = path.resolve(options.home || resolvePaths().root);
+    const release = acquireLock(home);
+    try {
+        assertDaemonStopped(home);
+        recoverJournal(home);
+        const plan = planAuxiliaryModelMigration(home);
+        const backup = options.apply ? applyMigration(plan) : null;
+        return {
+            ok: true,
+            mode: options.apply ? 'applied' : 'dry-run',
+            home,
+            changedFiles: plan.changes.length,
+            backup,
+            summary: plan.summary,
+        };
+    }
+    finally {
+        release();
+    }
+}
+/** Apply pending configuration schema migrations before daemon registration. */
+export async function ensureAuxiliaryModelMigrationOnStartup() {
+    const home = resolvePaths().root;
+    try {
+        const result = runAuxiliaryModelSchemaMigration({ home, apply: true });
+        if (result.changedFiles === 0)
+            return null;
+        return {
+            mode: 'applied',
+            changedFiles: result.changedFiles,
+            backup: result.backup,
+            summary: result.summary,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ConfigError('AUXILIARY_MODEL_MIGRATION_FAILED', `Automatic Session Renew auxiliary-model schema migration failed: ${detail}`, { cause: error });
+    }
+}