dominds 0.1.0

package/dist/server/setup-routes.js

@@ -0,0 +1,697 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSetupStatusResponse = buildSetupStatusResponse;
+exports.buildSetupFileResponse = buildSetupFileResponse;
+exports.handleWriteShellEnv = handleWriteShellEnv;
+exports.handleWriteTeamYaml = handleWriteTeamYaml;
+exports.handleWriteWorkspaceLlmYaml = handleWriteWorkspaceLlmYaml;
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const client_1 = require("../llm/client");
+const log_1 = require("../log");
+const log = (0, log_1.createLogger)('setup-routes');
+const TEAM_YAML_PATH = path_1.default.join('.minds', 'team.yaml');
+const WORKSPACE_LLM_YAML_PATH = path_1.default.join('.minds', 'llm.yaml');
+const BUILTIN_DEFAULTS_YAML_PATH = path_1.default.join(__dirname, '..', 'llm', 'defaults.yaml');
+const DOMINDS_ENV_BLOCK_START = '# >>> dominds env >>>';
+const DOMINDS_ENV_BLOCK_END = '# <<< dominds env <<<';
+async function buildSetupStatusResponse() {
+    const builtin = await loadBuiltinProviders();
+    const merged = await client_1.LlmConfig.load();
+    const shellEnv = typeof process.env.SHELL === 'string' ? process.env.SHELL : null;
+    const shellKind = resolveShellKind(shellEnv);
+    const home = os_1.default.homedir();
+    const bashrcPath = path_1.default.join(home, '.bashrc');
+    const zshrcPath = path_1.default.join(home, '.zshrc');
+    const rc = {
+        bashrc: await statRcFile(bashrcPath),
+        zshrc: await statRcFile(zshrcPath),
+    };
+    const teamYaml = await readTeamYamlMemberDefaults();
+    const requirement = await resolveSetupRequirement({
+        teamYaml,
+        llmProviders: merged.providers,
+    });
+    const workspaceLlmYaml = await readWorkspaceLlmYamlProviderKeys();
+    if (builtin.kind === 'error') {
+        return {
+            success: false,
+            requirement,
+            shell: { env: shellEnv, kind: shellKind, defaultRc: shellKindToDefaultRc(shellKind) },
+            rc,
+            teamYaml,
+            workspaceLlmYaml,
+            providers: [],
+            error: builtin.errorText,
+        };
+    }
+    const providers = await buildProviderSummaries(builtin.providers, builtin.providerKeysInOrder, {
+        bashrcPath,
+        zshrcPath,
+    });
+    return {
+        success: true,
+        requirement,
+        shell: { env: shellEnv, kind: shellKind, defaultRc: shellKindToDefaultRc(shellKind) },
+        rc,
+        teamYaml,
+        workspaceLlmYaml,
+        providers,
+    };
+}
+async function buildSetupFileResponse(kind) {
+    if (kind === 'defaults_yaml') {
+        try {
+            const raw = await promises_1.default.readFile(BUILTIN_DEFAULTS_YAML_PATH, 'utf-8');
+            return { success: true, kind, path: BUILTIN_DEFAULTS_YAML_PATH, raw };
+        }
+        catch {
+            return {
+                success: false,
+                kind,
+                path: BUILTIN_DEFAULTS_YAML_PATH,
+                error: 'Failed to read defaults.yaml',
+            };
+        }
+    }
+    if (kind === 'workspace_llm_yaml') {
+        const p = WORKSPACE_LLM_YAML_PATH;
+        const exists = await fileExists(p);
+        if (!exists) {
+            return { success: false, kind, path: p, error: 'Missing .minds/llm.yaml' };
+        }
+        try {
+            const raw = await promises_1.default.readFile(p, 'utf-8');
+            return { success: true, kind, path: p, raw };
+        }
+        catch {
+            return { success: false, kind, path: p, error: 'Failed to read .minds/llm.yaml' };
+        }
+    }
+    const _exhaustive = kind;
+    return { success: false, kind: _exhaustive, path: '', error: 'Unsupported kind' };
+}
+async function handleWriteShellEnv(rawBody) {
+    let parsed;
+    try {
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        return { kind: 'bad_request', errorText: 'Invalid JSON body' };
+    }
+    const req = parseWriteShellEnvRequest(parsed);
+    if (!req) {
+        return { kind: 'bad_request', errorText: 'Invalid request body' };
+    }
+    const allowed = await buildAllowedEnvVarSet();
+    if (!allowed.has(req.envVar)) {
+        return { kind: 'bad_request', errorText: `Unsupported env var: ${req.envVar}` };
+    }
+    try {
+        // Apply to the current backend process immediately so setup can proceed without a restart.
+        process.env[req.envVar] = req.value;
+        const home = os_1.default.homedir();
+        const targets = req.targets;
+        const outcomes = [];
+        for (const target of targets) {
+            const filePath = path_1.default.join(home, target === 'bashrc' ? '.bashrc' : '.zshrc');
+            const result = await upsertEnvVarIntoRcFile(filePath, req.envVar, req.value);
+            outcomes.push({ target, path: filePath, result });
+        }
+        return { kind: 'ok', response: { success: true, outcomes } };
+    }
+    catch (error) {
+        log.error('Failed to write shell env vars', error);
+        return { kind: 'error', errorText: 'Failed to write shell env vars' };
+    }
+}
+async function handleWriteTeamYaml(rawBody) {
+    const outPath = TEAM_YAML_PATH;
+    let parsed;
+    try {
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        return { kind: 'bad_request', errorText: 'Invalid JSON body', path: outPath };
+    }
+    const req = parseWriteTeamYamlRequest(parsed);
+    if (!req) {
+        return { kind: 'bad_request', errorText: 'Invalid request body', path: outPath };
+    }
+    const llmCfg = await client_1.LlmConfig.load();
+    const providerCfg = llmCfg.providers[req.provider];
+    if (!providerCfg) {
+        return { kind: 'bad_request', errorText: `Unknown provider: ${req.provider}`, path: outPath };
+    }
+    const models = providerCfg.models ?? {};
+    if (!Object.prototype.hasOwnProperty.call(models, req.model)) {
+        return {
+            kind: 'bad_request',
+            errorText: `Unknown model for provider ${req.provider}: ${req.model}`,
+            path: outPath,
+        };
+    }
+    const exists = await fileExists(outPath);
+    if (exists && req.overwrite !== true) {
+        return { kind: 'conflict', errorText: 'team.yaml already exists', path: outPath };
+    }
+    try {
+        await promises_1.default.mkdir(path_1.default.dirname(outPath), { recursive: true });
+        const content = buildMinimalTeamYaml(req);
+        await promises_1.default.writeFile(outPath, content, 'utf-8');
+        return {
+            kind: 'ok',
+            response: {
+                success: true,
+                path: outPath,
+                action: exists ? 'overwritten' : 'created',
+            },
+        };
+    }
+    catch (error) {
+        log.error('Failed to write team.yaml', error);
+        return { kind: 'error', errorText: 'Failed to write team.yaml', path: outPath };
+    }
+}
+async function handleWriteWorkspaceLlmYaml(rawBody) {
+    const outPath = WORKSPACE_LLM_YAML_PATH;
+    let parsed;
+    try {
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        return { kind: 'bad_request', errorText: 'Invalid JSON body', path: outPath };
+    }
+    const req = parseWriteWorkspaceLlmYamlRequest(parsed);
+    if (!req) {
+        return { kind: 'bad_request', errorText: 'Invalid request body', path: outPath };
+    }
+    // Guardrails: ensure it is valid YAML and has a providers object.
+    try {
+        const parsedYaml = yaml_1.default.parse(req.raw);
+        if (!isRecord(parsedYaml) || !isRecord(parsedYaml['providers'])) {
+            return {
+                kind: 'bad_request',
+                errorText: 'Invalid llm.yaml: expected a top-level providers object',
+                path: outPath,
+            };
+        }
+    }
+    catch {
+        return { kind: 'bad_request', errorText: 'Invalid YAML content', path: outPath };
+    }
+    const exists = await fileExists(outPath);
+    if (exists && req.overwrite !== true) {
+        return { kind: 'conflict', errorText: 'llm.yaml already exists', path: outPath };
+    }
+    try {
+        await promises_1.default.mkdir(path_1.default.dirname(outPath), { recursive: true });
+        await promises_1.default.writeFile(outPath, req.raw.endsWith('\n') ? req.raw : `${req.raw}\n`, 'utf-8');
+        return {
+            kind: 'ok',
+            response: {
+                success: true,
+                path: outPath,
+                action: exists ? 'overwritten' : 'created',
+            },
+        };
+    }
+    catch (error) {
+        log.error('Failed to write llm.yaml', error);
+        return { kind: 'error', errorText: 'Failed to write llm.yaml', path: outPath };
+    }
+}
+async function loadBuiltinProviders() {
+    try {
+        const raw = await promises_1.default.readFile(BUILTIN_DEFAULTS_YAML_PATH, 'utf-8');
+        const doc = yaml_1.default.parseDocument(raw);
+        const parsed = doc.toJS();
+        if (!isRecord(parsed) || !isRecord(parsed.providers)) {
+            return { kind: 'error', errorText: 'Invalid defaults.yaml: expected providers object' };
+        }
+        const providerKeysInOrder = extractProvidersKeysFromDefaultsYamlDoc(doc);
+        return {
+            kind: 'ok',
+            providers: parsed.providers,
+            providerKeysInOrder,
+        };
+    }
+    catch (error) {
+        return { kind: 'error', errorText: 'Failed to load defaults.yaml' };
+    }
+}
+async function buildAllowedEnvVarSet() {
+    const out = new Set();
+    const builtin = await loadBuiltinProviders();
+    if (builtin.kind === 'ok') {
+        for (const provider of Object.values(builtin.providers)) {
+            if (typeof provider.apiKeyEnvVar === 'string')
+                out.add(provider.apiKeyEnvVar);
+        }
+    }
+    const merged = await client_1.LlmConfig.load();
+    for (const provider of Object.values(merged.providers)) {
+        if (typeof provider.apiKeyEnvVar === 'string')
+            out.add(provider.apiKeyEnvVar);
+    }
+    return out;
+}
+async function buildProviderSummaries(providers, providerKeysInOrder, paths) {
+    const envSet = [];
+    const envMissing = [];
+    for (const [providerKey, cfg] of orderedProviderEntries(providers, providerKeysInOrder)) {
+        const envVar = cfg.apiKeyEnvVar;
+        const envVarIsSet = typeof process.env[envVar] === 'string' && process.env[envVar] !== '';
+        const bashrcHas = await rcHasEnvVar(paths.bashrcPath, envVar);
+        const zshrcHas = await rcHasEnvVar(paths.zshrcPath, envVar);
+        const models = Object.entries(cfg.models ?? {}).map(([modelKey, modelInfo]) => {
+            const info = isRecord(modelInfo) ? modelInfo : {};
+            const name = typeof info.name === 'string' ? info.name : undefined;
+            const contextWindow = typeof info.context_window === 'string' ? info.context_window : undefined;
+            const contextLength = typeof info.context_length === 'number' ? info.context_length : undefined;
+            const inputLength = typeof info.input_length === 'number' ? info.input_length : undefined;
+            const outputLength = typeof info.output_length === 'number' ? info.output_length : undefined;
+            return {
+                key: modelKey,
+                name,
+                contextWindow,
+                contextLength,
+                inputLength,
+                outputLength,
+                verified: envVarIsSet,
+            };
+        });
+        const prominent = extractProminentEnumModelParams(cfg.model_param_options);
+        const summary = {
+            providerKey,
+            name: cfg.name,
+            apiType: cfg.apiType,
+            baseUrl: cfg.baseUrl,
+            apiKeyEnvVar: envVar,
+            techSpecUrl: cfg.tech_spec_url,
+            apiMgmtUrl: cfg.api_mgmt_url,
+            envVar: { isSet: envVarIsSet, bashrcHas, zshrcHas },
+            models,
+            ...(prominent.length > 0 ? { prominentModelParams: prominent } : {}),
+        };
+        // Keep YAML order stable, but list env-var-ready providers first.
+        if (envVarIsSet) {
+            envSet.push(summary);
+        }
+        else {
+            envMissing.push(summary);
+        }
+    }
+    return [...envSet, ...envMissing];
+}
+function extractProminentEnumModelParams(modelParamOptions) {
+    if (!modelParamOptions)
+        return [];
+    const out = [];
+    const sections = [];
+    const addSection = (namespace, section) => {
+        if (section && typeof section === 'object') {
+            sections.push([namespace, section]);
+        }
+    };
+    addSection('general', modelParamOptions.general);
+    addSection('codex', modelParamOptions.codex);
+    addSection('openai', modelParamOptions.openai);
+    addSection('anthropic', modelParamOptions.anthropic);
+    for (const [namespace, section] of sections) {
+        for (const [key, optUnknown] of Object.entries(section)) {
+            if (!optUnknown || typeof optUnknown !== 'object')
+                continue;
+            const opt = optUnknown;
+            if (opt.type !== 'enum')
+                continue;
+            if (opt.prominent !== true)
+                continue;
+            if (typeof opt.description !== 'string')
+                continue;
+            if (!Array.isArray(opt.values) || !opt.values.every((v) => typeof v === 'string'))
+                continue;
+            const defaultValue = typeof opt.default === 'string' && opt.values.includes(opt.default)
+                ? opt.default
+                : undefined;
+            out.push({
+                namespace,
+                key,
+                description: opt.description,
+                values: opt.values,
+                ...(defaultValue ? { defaultValue } : {}),
+            });
+        }
+    }
+    return out;
+}
+function orderedProviderEntries(providers, providerKeysInOrder) {
+    const out = [];
+    const seen = new Set();
+    for (const k of providerKeysInOrder) {
+        const cfg = providers[k];
+        if (!cfg)
+            continue;
+        out.push([k, cfg]);
+        seen.add(k);
+    }
+    // Any providers not present in the YAML map (should be rare) are appended.
+    for (const [k, cfg] of Object.entries(providers)) {
+        if (seen.has(k))
+            continue;
+        out.push([k, cfg]);
+    }
+    return out;
+}
+function extractYamlMapStringKeys(value) {
+    if (!yaml_1.default.isMap(value))
+        return [];
+    const out = [];
+    for (const pair of value.items) {
+        if (!yaml_1.default.isPair(pair))
+            continue;
+        const keyNode = pair.key;
+        if (!yaml_1.default.isScalar(keyNode))
+            continue;
+        const keyValue = keyNode.value;
+        if (typeof keyValue !== 'string' || keyValue === '')
+            continue;
+        out.push(keyValue);
+    }
+    return out;
+}
+function extractProvidersKeysFromDefaultsYamlDoc(doc) {
+    const root = doc.contents;
+    if (!yaml_1.default.isMap(root))
+        return [];
+    for (const pair of root.items) {
+        if (!yaml_1.default.isPair(pair))
+            continue;
+        const keyNode = pair.key;
+        if (!yaml_1.default.isScalar(keyNode))
+            continue;
+        if (keyNode.value !== 'providers')
+            continue;
+        const valNode = pair.value;
+        return extractYamlMapStringKeys(valNode);
+    }
+    return [];
+}
+async function statRcFile(filePath) {
+    const exists = await fileExists(filePath);
+    const writable = exists ? await isWritable(filePath) : await isWritable(path_1.default.dirname(filePath));
+    return { path: filePath, exists, writable };
+}
+async function readTeamYamlMemberDefaults() {
+    const exists = await fileExists(TEAM_YAML_PATH);
+    if (!exists)
+        return { path: TEAM_YAML_PATH, exists: false };
+    try {
+        const raw = await promises_1.default.readFile(TEAM_YAML_PATH, 'utf-8');
+        const parsed = yaml_1.default.parse(raw);
+        if (!isRecord(parsed)) {
+            return {
+                path: TEAM_YAML_PATH,
+                exists: true,
+                parseError: 'Invalid team.yaml (not an object)',
+            };
+        }
+        const memberDefaultsUnknown = parsed['member_defaults'];
+        if (!isRecord(memberDefaultsUnknown)) {
+            return {
+                path: TEAM_YAML_PATH,
+                exists: true,
+                parseError: 'Invalid team.yaml (missing member_defaults object)',
+            };
+        }
+        const provider = typeof memberDefaultsUnknown['provider'] === 'string'
+            ? memberDefaultsUnknown['provider']
+            : undefined;
+        const model = typeof memberDefaultsUnknown['model'] === 'string'
+            ? memberDefaultsUnknown['model']
+            : undefined;
+        return { path: TEAM_YAML_PATH, exists: true, memberDefaults: { provider, model } };
+    }
+    catch (error) {
+        return { path: TEAM_YAML_PATH, exists: true, parseError: 'Failed to parse team.yaml' };
+    }
+}
+async function readWorkspaceLlmYamlProviderKeys() {
+    const exists = await fileExists(WORKSPACE_LLM_YAML_PATH);
+    if (!exists)
+        return { path: WORKSPACE_LLM_YAML_PATH, exists: false };
+    try {
+        const raw = await promises_1.default.readFile(WORKSPACE_LLM_YAML_PATH, 'utf-8');
+        const parsed = yaml_1.default.parse(raw);
+        if (!isRecord(parsed)) {
+            return {
+                path: WORKSPACE_LLM_YAML_PATH,
+                exists: true,
+                parseError: 'Invalid llm.yaml (not an object)',
+            };
+        }
+        const providersUnknown = parsed['providers'];
+        if (!isRecord(providersUnknown)) {
+            return {
+                path: WORKSPACE_LLM_YAML_PATH,
+                exists: true,
+                parseError: 'Invalid llm.yaml (missing providers object)',
+            };
+        }
+        return {
+            path: WORKSPACE_LLM_YAML_PATH,
+            exists: true,
+            providerKeys: Object.keys(providersUnknown).sort(),
+        };
+    }
+    catch (error) {
+        return { path: WORKSPACE_LLM_YAML_PATH, exists: true, parseError: 'Failed to parse llm.yaml' };
+    }
+}
+async function resolveSetupRequirement(params) {
+    const ty = params.teamYaml;
+    if (!ty.exists) {
+        return { kind: 'missing_team_yaml', teamYamlPath: ty.path };
+    }
+    if (typeof ty.parseError === 'string') {
+        return { kind: 'invalid_team_yaml', teamYamlPath: ty.path, errorText: ty.parseError };
+    }
+    const md = ty.memberDefaults;
+    if (!md ||
+        typeof md.provider !== 'string' ||
+        md.provider === '' ||
+        typeof md.model !== 'string' ||
+        md.model === '') {
+        const missing = [];
+        if (!md || typeof md.provider !== 'string' || md.provider === '')
+            missing.push('provider');
+        if (!md || typeof md.model !== 'string' || md.model === '')
+            missing.push('model');
+        return { kind: 'missing_member_defaults_fields', teamYamlPath: ty.path, missing };
+    }
+    const providerKey = md.provider;
+    const modelKey = md.model;
+    const providerCfg = params.llmProviders[providerKey];
+    if (!providerCfg) {
+        return { kind: 'unknown_provider', provider: providerKey };
+    }
+    const models = providerCfg.models ?? {};
+    if (!Object.prototype.hasOwnProperty.call(models, modelKey)) {
+        return { kind: 'unknown_model', provider: providerKey, model: modelKey };
+    }
+    const envVar = providerCfg.apiKeyEnvVar;
+    const rawEnv = process.env[envVar];
+    const envSet = typeof rawEnv === 'string' && rawEnv !== '';
+    if (!envSet) {
+        return { kind: 'missing_provider_env', provider: providerKey, envVar };
+    }
+    return { kind: 'ok' };
+}
+function resolveShellKind(shellEnv) {
+    if (!shellEnv)
+        return 'other';
+    const base = path_1.default.basename(shellEnv);
+    if (base === 'zsh')
+        return 'zsh';
+    if (base === 'bash')
+        return 'bash';
+    return 'other';
+}
+function shellKindToDefaultRc(kind) {
+    if (kind === 'bash')
+        return 'bashrc';
+    if (kind === 'zsh')
+        return 'zshrc';
+    return 'unknown';
+}
+function parseWriteShellEnvRequest(value) {
+    if (!isRecord(value))
+        return null;
+    const envVar = value['envVar'];
+    const rawVal = value['value'];
+    const targetsUnknown = value['targets'];
+    if (typeof envVar !== 'string' || !isSafeEnvVarName(envVar))
+        return null;
+    if (typeof rawVal !== 'string')
+        return null;
+    if (!Array.isArray(targetsUnknown))
+        return null;
+    const targets = [];
+    for (const t of targetsUnknown) {
+        if (t === 'bashrc' || t === 'zshrc')
+            targets.push(t);
+    }
+    if (targets.length === 0)
+        return null;
+    return { envVar, value: rawVal, targets };
+}
+function parseWriteTeamYamlRequest(value) {
+    if (!isRecord(value))
+        return null;
+    const provider = value['provider'];
+    const model = value['model'];
+    const overwrite = value['overwrite'];
+    if (typeof provider !== 'string' || provider === '')
+        return null;
+    if (typeof model !== 'string' || model === '')
+        return null;
+    if (typeof overwrite !== 'boolean')
+        return null;
+    const modelParamsUnknown = value['modelParams'];
+    const modelParams = parseOptionalTeamModelParams(modelParamsUnknown);
+    if (modelParamsUnknown !== undefined && !modelParams)
+        return null;
+    return modelParams ? { provider, model, overwrite, modelParams } : { provider, model, overwrite };
+}
+function parseWriteWorkspaceLlmYamlRequest(value) {
+    if (!isRecord(value))
+        return null;
+    const raw = value['raw'];
+    const overwrite = value['overwrite'];
+    if (typeof raw !== 'string')
+        return null;
+    if (typeof overwrite !== 'boolean')
+        return null;
+    return { raw, overwrite };
+}
+function buildMinimalTeamYaml(req) {
+    // Minimal config, intentionally no members.
+    const memberDefaults = {
+        provider: req.provider,
+        model: req.model,
+    };
+    if (req.modelParams && Object.keys(req.modelParams).length > 0) {
+        memberDefaults['model_params'] = req.modelParams;
+    }
+    const doc = { member_defaults: memberDefaults };
+    return yaml_1.default.stringify(doc);
+}
+function parseOptionalTeamModelParams(value) {
+    if (value === undefined)
+        return null;
+    if (!isRecord(value))
+        return null;
+    const out = {};
+    for (const [namespace, nsUnknown] of Object.entries(value)) {
+        if (namespace !== 'general' &&
+            namespace !== 'codex' &&
+            namespace !== 'openai' &&
+            namespace !== 'anthropic')
+            return null;
+        if (!isRecord(nsUnknown))
+            return null;
+        const nsOut = {};
+        for (const [k, v] of Object.entries(nsUnknown)) {
+            if (typeof v !== 'string')
+                return null;
+            nsOut[k] = v;
+        }
+        if (Object.keys(nsOut).length > 0)
+            out[namespace] = nsOut;
+    }
+    return Object.keys(out).length > 0 ? out : {};
+}
+function isSafeEnvVarName(name) {
+    return /^[A-Z_][A-Z0-9_]*$/.test(name);
+}
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath, fs_1.default.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isWritable(filePath) {
+    try {
+        await promises_1.default.access(filePath, fs_1.default.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function rcHasEnvVar(rcPath, envVar) {
+    try {
+        const raw = await promises_1.default.readFile(rcPath, 'utf-8');
+        const re = new RegExp(`(^|\\n)\\s*export\\s+${escapeRegExp(envVar)}=`, 'm');
+        return re.test(raw);
+    }
+    catch {
+        return false;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function shellQuoteSingle(value) {
+    // Safe POSIX shell single-quoted string: close quote, escape single quote, reopen.
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function upsertEnvVarIntoRcFile(filePath, envVar, value) {
+    const exportLine = `export ${envVar}=${shellQuoteSingle(value)}`;
+    const exists = await fileExists(filePath);
+    const original = exists ? await promises_1.default.readFile(filePath, 'utf-8') : '';
+    const normalized = original.replace(/\r\n/g, '\n');
+    const lines = normalized === '' ? [] : normalized.split('\n');
+    const startIdx = lines.findIndex((l) => l.trim() === DOMINDS_ENV_BLOCK_START);
+    const endIdx = lines.findIndex((l) => l.trim() === DOMINDS_ENV_BLOCK_END);
+    let nextLines = lines;
+    if (startIdx >= 0 && endIdx > startIdx) {
+        const blockLines = lines.slice(startIdx + 1, endIdx);
+        const updatedBlock = upsertExportLine(blockLines, envVar, exportLine);
+        nextLines = [...lines.slice(0, startIdx + 1), ...updatedBlock, ...lines.slice(endIdx)];
+    }
+    else {
+        // Append a new managed block.
+        const block = [DOMINDS_ENV_BLOCK_START, exportLine, DOMINDS_ENV_BLOCK_END];
+        const joiner = nextLines.length > 0 ? [''] : [];
+        nextLines = [...nextLines, ...joiner, ...block];
+    }
+    // Ensure file ends with newline for friendliness.
+    let next = nextLines.join('\n');
+    if (!next.endsWith('\n'))
+        next += '\n';
+    await promises_1.default.writeFile(filePath, next, 'utf-8');
+    return exists ? 'updated' : 'created';
+}
+function upsertExportLine(lines, envVar, exportLine) {
+    const re = new RegExp(`^\\s*export\\s+${escapeRegExp(envVar)}=`);
+    const idx = lines.findIndex((l) => re.test(l));
+    if (idx >= 0) {
+        const copy = [...lines];
+        copy[idx] = exportLine;
+        return copy;
+    }
+    return [...lines, exportLine];
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}